diff --git a/client/dive-common/apispec.ts b/client/dive-common/apispec.ts
index 977006bdd..7372daa16 100644
--- a/client/dive-common/apispec.ts
+++ b/client/dive-common/apispec.ts
@@ -895,6 +895,24 @@ export interface VideoSearchQueryResponse {
   feedback_requests?: VideoSearchResult[];
 }
 
+/** One result placed in descriptor space around the query (at the origin). */
+export interface VideoSearchLayoutPoint {
+  ref: string;
+  /** Offset from the query along the three principal axes of the result set. */
+  position: [number, number, number];
+  /** Full-dimensional descriptor distance from the query. */
+  distance: number;
+}
+
+export interface VideoSearchLayoutResponse {
+  success: boolean;
+  error?: string;
+  dimensions?: number;
+  points?: VideoSearchLayoutPoint[];
+  /** Results with no stored descriptor vector, left out of the layout. */
+  missing?: string[];
+}
+
 export {
   provideApi,
   useApi,
diff --git a/client/dive-common/review/chipRenderer.spec.ts b/client/dive-common/review/chipRenderer.spec.ts
index b7a77cada..c500eabd9 100644
--- a/client/dive-common/review/chipRenderer.spec.ts
+++ b/client/dive-common/review/chipRenderer.spec.ts
@@ -1,5 +1,5 @@
 import {
-  chipRegion, chipScale, chipSizeFor, frameRegion, toChipPoint, toImagePoint,
+  boxRegion, chipRegion, chipScale, chipSizeFor, frameRegion, toChipPoint, toImagePoint,
 } from './chipRenderer';
 
 describe('chipRegion', () => {
@@ -30,6 +30,18 @@ describe('chipRegion', () => {
   });
 });
 
+describe('boxRegion', () => {
+  it('is the box itself, with no context and no squaring', () => {
+    expect(boxRegion([10, 20, 30, 60])).toEqual({
+      x: 10, y: 20, width: 20, height: 40,
+    });
+    expect(boxRegion([30, 60, 10, 20])).toEqual({
+      x: 10, y: 20, width: 20, height: 40,
+    });
+    expect(boxRegion([5, 5, 5, 5])).toMatchObject({ width: 1, height: 1 });
+  });
+});
+
 describe('chipSizeFor', () => {
   it('rounds cell sizes up to a bucket and caps at the largest', () => {
     expect(chipSizeFor(100)).toBe(128);
diff --git a/client/dive-common/review/chipRenderer.ts b/client/dive-common/review/chipRenderer.ts
index a842e82bc..a6f33ba8a 100644
--- a/client/dive-common/review/chipRenderer.ts
+++ b/client/dive-common/review/chipRenderer.ts
@@ -16,6 +16,11 @@ export interface ChipRenderOptions {
   aspect?: number;
   /** Box outline colour; omit to draw no outline. */
   outline?: string;
+  /**
+   * Crop to the box itself: no context and no squaring, so the chip takes the
+   * box's own shape. Overrides padding and aspect.
+   */
+  tight?: boolean;
   /** JPEG quality. */
   quality?: number;
 }
@@ -71,6 +76,17 @@ export function chipRegion(bounds: RectBounds, padding: number, aspect = 1): Chi
   };
 }
 
+/** Exactly the box, whatever its shape. */
+export function boxRegion(bounds: RectBounds): ChipRegion {
+  const [x1, y1, x2, y2] = bounds;
+  return {
+    x: Math.min(x1, x2),
+    y: Math.min(y1, y2),
+    width: Math.max(1, Math.abs(x2 - x1)),
+    height: Math.max(1, Math.abs(y2 - y1)),
+  };
+}
+
 /** Pixel sizes chips are rendered at; cells pick the smallest that covers them. */
 export const CHIP_SIZE_BUCKETS = [128, 192, 256, 384, 512, 768];
 
@@ -108,9 +124,11 @@ export function renderChip(
   bounds: RectBounds | null,
   options: ChipRenderOptions,
 ): RenderedChip {
-  const region = bounds
-    ? chipRegion(bounds, options.padding, options.aspect)
-    : frameRegion(frame.width, frame.height, options.aspect);
+  let region = frameRegion(frame.width, frame.height, options.aspect);
+  if (bounds) {
+    region = options.tight
+      ? boxRegion(bounds) : chipRegion(bounds, options.padding, options.aspect);
+  }
   const scale = chipScale(region, options.size);
   const canvas = document.createElement('canvas');
   canvas.width = Math.max(1, Math.round(region.width * scale));
diff --git a/client/dive-common/review/chipStore.ts b/client/dive-common/review/chipStore.ts
index be19fbba4..db61d7f55 100644
--- a/client/dive-common/review/chipStore.ts
+++ b/client/dive-common/review/chipStore.ts
@@ -19,6 +19,8 @@ export interface ChipStoreOptions {
   /** Chip width / height, matching the cells the chips are shown in. */
   aspect: number;
   outline: string;
+  /** Crop to the box itself, ignoring padding and aspect. */
+  tight?: boolean;
 }
 
 export interface ChipStoreDeps {
@@ -72,7 +74,8 @@ export function createChipStore(deps: ChipStoreDeps, initial: ChipStoreOptions)
   /** Re-render everything when the crop or resolution changes. */
   function setOptions(next: ChipStoreOptions) {
     if (next.padding === options.padding && next.size === options.size
-      && next.aspect === options.aspect && next.outline === options.outline) {
+      && next.aspect === options.aspect && next.outline === options.outline
+      && !!next.tight === !!options.tight) {
       return;
     }
     options = { ...next };
diff --git a/client/platform/desktop/backend/ipcService.ts b/client/platform/desktop/backend/ipcService.ts
index bbde40635..7dcb3b259 100644
--- a/client/platform/desktop/backend/ipcService.ts
+++ b/client/platform/desktop/backend/ipcService.ts
@@ -717,6 +717,11 @@ export default function register() {
     return manager.refine(args.positiveIds, args.negativeIds);
   });
 
+  ipcMain.handle('video-search-layout', async (_, args: { refs: string[] }) => {
+    const manager = videoSearch.getQueryServiceManager();
+    return manager.layoutResults(args.refs);
+  });
+
   ipcMain.handle('video-search-export-model', async (_, args: { name: string }) => {
     const outputDir = await videoSearch.exportSearchModel(settings.get(), args.name);
     return { success: true, outputDir };
diff --git a/client/platform/desktop/backend/native/common.spec.ts b/client/platform/desktop/backend/native/common.spec.ts
index bc78fd90a..9149386c5 100644
--- a/client/platform/desktop/backend/native/common.spec.ts
+++ b/client/platform/desktop/backend/native/common.spec.ts
@@ -3196,12 +3196,12 @@ describe('resumable training jobs', () => {
     expect(found.map((j) => j.workingDir)).toEqual([npath.join(jobsDir, 'interrupted')]);
   });
 
-  it('excludes legacy successful runs with an emptied category_models', async () => {
+  it('excludes legacy successful runs with an emptied trained_model', async () => {
     mockJobsFolder({
       legacySuccess: jobDirConfig(
         'legacySuccess',
         {},
-        ['deep_training', 'category_models', 'input_folder_list.txt', 'input_truth_list.txt'],
+        ['deep_training', 'trained_model', 'input_folder_list.txt', 'input_truth_list.txt'],
       ),
       legacyInterrupted: jobDirConfig('legacyInterrupted', {}),
     });
diff --git a/client/platform/desktop/backend/native/common.ts b/client/platform/desktop/backend/native/common.ts
index 02d13c896..b86e6c4a1 100644
--- a/client/platform/desktop/backend/native/common.ts
+++ b/client/platform/desktop/backend/native/common.ts
@@ -77,6 +77,7 @@ import processTrackAttributes from './attributeProcessor';
 import { upgrade } from './migrations';
 // TODO:  Check to Refactor this
 import { getMultiCamUrls, transcodeMultiCam } from './multiCamUtils';
+import { extractModelPackTo } from './modelPack';
 import {
   loadRegistrationFiles, referenceCameraName, saveRegistrationToDatasetDir,
 } from './cameraRegistration';
@@ -1904,13 +1905,45 @@ async function ingestDataFiles(
     processedFiles, annotationsSaved, meta, warnings: outwarnings, speciesStyling,
   };
 }
+const TrainedModelPackName = 'trained_model.zip';
+// Newest first; the legacy name is what releases before the pack wrote
+const TrainedModelFolderNames = ['trained_model', 'category_models'];
+
+async function findTrainedModelDir(workingDir: string): Promise<string | undefined> {
+  const candidates = TrainedModelFolderNames.map((name) => npath.join(workingDir, name));
+  const present = await Promise.all(candidates.map((candidate) => fs.pathExists(candidate)));
+  return candidates.find((_, index) => present[index]);
+}
+
 /**
  * Need to take the trained pipeline if it exists and place it in the DIVE_Pipelines folder
  */
 async function processTrainedPipeline(settings: Settings, args: RunTraining, workingDir: string) {
-  //Look for trained_detector.zip and detector.pipe and move them to DIVE_Pipelines folder
   const allowedPatterns = /^detector.+|^tracker.+|^generate.+/;
-  const trainedDir = npath.join(workingDir, '/trained_model');
+  const baseFolder = npath.join(settings.dataPath, PipelinesFolderName);
+  if (!fs.existsSync(baseFolder)) {
+    await fs.mkdir(baseFolder);
+  }
+  const folderName = npath.join(baseFolder, args.pipelineName);
+  if (!fs.existsSync(folderName)) {
+    await fs.mkdir(folderName);
+  }
+
+  // Current VIAME packs the whole output into one zip
+  const pack = npath.join(workingDir, TrainedModelPackName);
+  if (await fs.pathExists(pack)) {
+    await extractModelPackTo(pack, folderName);
+    const packContents = await fs.readdir(folderName);
+    if (!packContents.some((p) => p.match(allowedPatterns))) {
+      throw new Error(`Could not located trained pipe file inside of ${pack}`);
+    }
+    await fs.remove(pack);
+    return packContents;
+  }
+
+  // An unpacked folder: SVM trainers keep one, as did older VIAME releases
+  const trainedDir = await findTrainedModelDir(workingDir)
+    ?? npath.join(workingDir, TrainedModelFolderNames[0]);
   const exists = await fs.pathExists(trainedDir);
   if (!exists) {
     throw new Error(`Path: ${trainedDir} does not exist`);
@@ -1921,15 +1954,6 @@ async function processTrainedPipeline(settings: Settings, args: RunTraining, wor
   if (!pipes.length) {
     throw new Error(`Could not located trained pipe file inside of ${trainedDir}`);
   }
-  const baseFolder = npath.join(settings.dataPath, PipelinesFolderName);
-  if (!fs.existsSync(baseFolder)) {
-    await fs.mkdir(baseFolder);
-  }
-
-  const folderName = npath.join(baseFolder, args.pipelineName);
-  if (!fs.existsSync(folderName)) {
-    await fs.mkdir(folderName);
-  }
   //Move detector and model to the new folder
   await Promise.all(folderContents.map(async (item) => {
     const abspath = npath.join(trainedDir, item);
@@ -1977,10 +2001,10 @@ async function findResumableTrainingJobs(settings: Settings): Promise<DesktopJob
       const required = ['deep_training', 'input_folder_list.txt', 'input_truth_list.txt'];
       if (!required.every((f) => fs.existsSync(npath.join(workingDir, f)))) return;
       // Manifests predating final-status recording never carry an end time; a
-      // successful run's models were moved out of category_models, leaving it empty
+      // successful run's models were moved out of the model folder, leaving it empty
       if (manifest.endTime === undefined) {
-        const modelsDir = npath.join(workingDir, 'category_models');
-        if (fs.existsSync(modelsDir) && (await fs.readdir(modelsDir)).length === 0) return;
+        const modelsDir = await findTrainedModelDir(workingDir);
+        if (modelsDir && (await fs.readdir(modelsDir)).length === 0) return;
       }
       // The jobs folder may have been relocated since the manifest was written
       results.push({ ...manifest, workingDir });
diff --git a/client/platform/desktop/backend/native/modelPack.spec.ts b/client/platform/desktop/backend/native/modelPack.spec.ts
index 258e52d28..6ecf1b9ea 100644
--- a/client/platform/desktop/backend/native/modelPack.spec.ts
+++ b/client/platform/desktop/backend/native/modelPack.spec.ts
@@ -4,7 +4,10 @@ import fs from 'fs-extra';
 import archiver from 'archiver';
 import type { Pipe } from 'dive-common/apispec';
 import { PipelinesFolderName, Settings } from 'platform/desktop/constants';
-import { exportModelPack, importModelPack, modelPackPaths } from './modelPack';
+import * as common from './common';
+import {
+  exportModelPack, extractModelPackTo, importModelPack, modelPackPaths,
+} from './modelPack';
 
 const layouts: { name: string; files: string[]; expected: string[] }[] = JSON.parse(
   fs.readFileSync(path.resolve(__dirname, '../../../../../testutils/model-pack-layouts.json'), 'utf8'),
@@ -31,6 +34,27 @@ async function makeZip(files: string[], destination: string) {
   });
 }
 
+it('extracts a training pack as it is', async () => {
+  const source = path.join(temp, 'trained_model.zip');
+  await makeZip(['detector.pipe', 'trained_detector.pth', 'test_results/plots/pr.csv'], source);
+  const written = await extractModelPackTo(source, path.join(temp, 'out'));
+  expect(written.sort()).toEqual(['detector.pipe', 'test_results/plots/pr.csv', 'trained_detector.pth']);
+  expect(await fs.readFile(path.join(temp, 'out', 'test_results', 'plots', 'pr.csv'), 'utf8')).toBe('contents of test_results/plots/pr.csv');
+});
+
+it('moves a trained pack into the pipelines folder and drops the archive', async () => {
+  const jobDir = path.join(temp, 'DIVE_Jobs', 'job');
+  await fs.ensureDir(jobDir);
+  await makeZip(['detector.pipe', 'trained_detector.pth', 'MODEL_CARD.md'], path.join(jobDir, 'trained_model.zip'));
+  const contents = await common.processTrainedPipeline(settings, { pipelineName: 'fish' } as never, jobDir);
+  expect(contents.sort()).toEqual(['MODEL_CARD.md', 'detector.pipe', 'trained_detector.pth']);
+  expect(await fs.pathExists(path.join(jobDir, 'trained_model.zip'))).toBe(false);
+  expect(await fs.pathExists(path.join(temp, PipelinesFolderName, 'fish', 'detector.pipe'))).toBe(true);
+  await makeZip(['notes.txt'], path.join(jobDir, 'trained_model.zip'));
+  await expect(common.processTrainedPipeline(settings, { pipelineName: 'nopipe' } as never, jobDir))
+    .rejects.toThrow('Could not located trained pipe');
+});
+
 it.each(layouts)('imports $name layout with paths and contents intact', async ({ files, expected }) => {
   expect([...modelPackPaths(files).values()]).toEqual(expected);
   const source = path.join(temp, 'fish.zip');
diff --git a/client/platform/desktop/backend/native/modelPack.ts b/client/platform/desktop/backend/native/modelPack.ts
index 4958cb34b..014b2c166 100644
--- a/client/platform/desktop/backend/native/modelPack.ts
+++ b/client/platform/desktop/backend/native/modelPack.ts
@@ -121,6 +121,38 @@ export async function importModelPack(settings: Settings, filename: string): Pro
   }
 }
 
+/**
+ * Unpack an archive as it is, every entry under destination. Used for the
+ * pack `viame train` writes, whose layout is already the pipeline folder's.
+ */
+export async function extractModelPackTo(filename: string, destination: string): Promise<string[]> {
+  let zip: yauzl.ZipFile | undefined;
+  const written: string[] = [];
+  try {
+    zip = await openArchive(filename);
+    const entries = (await readEntries(zip)).filter((entry) => !entry.fileName.endsWith('/'));
+    for (const entry of entries) {
+      const relative = entry.fileName.replace(/\\/g, '/');
+      const parts = relative.split('/');
+      if (relative.startsWith('/') || parts.some((p) => p === '..' || p === '' || p.includes(':'))) {
+        throw new Error(`Unsafe model archive path: ${entry.fileName}`);
+      }
+      const target = path.join(destination, ...parts);
+      await fs.ensureDir(path.dirname(target));
+      const source = await new Promise<NodeJS.ReadableStream>((resolve, reject) => {
+        zip!.openReadStream(entry, (error, stream) => {
+          if (error || !stream) reject(error || new Error('Unable to read ZIP entry')); else resolve(stream);
+        });
+      });
+      await streamPipeline(source, fs.createWriteStream(target));
+      written.push(relative);
+    }
+  } finally {
+    zip?.close();
+  }
+  return written;
+}
+
 export async function exportModelPack(settings: Settings, model: Pipe, destination: string): Promise<void> {
   const root = await fs.realpath(path.join(settings.dataPath, PipelinesFolderName));
   const folder = await fs.realpath(path.dirname(model.pipe));
diff --git a/client/platform/desktop/backend/native/videoSearch.ts b/client/platform/desktop/backend/native/videoSearch.ts
index 8301bf8fd..1e892ad1c 100644
--- a/client/platform/desktop/backend/native/videoSearch.ts
+++ b/client/platform/desktop/backend/native/videoSearch.ts
@@ -770,6 +770,14 @@ export class QueryServiceManager extends EventEmitter {
     return QueryServiceManager.check(response, 'Query refinement');
   }
 
+  async layoutResults(refs: string[]): Promise<ServiceResponse> {
+    const response = await this.sendRequest({
+      command: 'layout_results',
+      refs,
+    }, 'Result layout');
+    return QueryServiceManager.check(response, 'Result layout');
+  }
+
   async exportModel(outputPath?: string): Promise<ServiceResponse> {
     const response = await this.sendRequest({
       command: 'export_model',
diff --git a/client/platform/desktop/frontend/api.ts b/client/platform/desktop/frontend/api.ts
index 74d87a1aa..f0e57d99b 100644
--- a/client/platform/desktop/frontend/api.ts
+++ b/client/platform/desktop/frontend/api.ts
@@ -12,6 +12,7 @@ import type {
   PipelineJobResult,
   ScoringDatasetSummary, ScoringJobArgs, ScoringResult, ScoringResultSummary, ScoringSourceOptions,
   VideoSearchIndexStatus, VideoSearchIndexMethod, VideoSearchQueryResponse, VideoSearchIndexInfo,
+  VideoSearchLayoutResponse,
 } from 'dive-common/apispec';
 import axios, { AxiosInstance } from 'axios';
 import { watch } from 'vue';
@@ -686,6 +687,11 @@ async function videoSearchRefine(positiveIds: string[], negativeIds: string[]):
   return window.diveDesktop.invoke('video-search-refine', { positiveIds, negativeIds });
 }
 
+/** Place the given results of the open query in 3D descriptor space around it. */
+async function videoSearchLayout(refs: string[]): Promise<VideoSearchLayoutResponse> {
+  return window.diveDesktop.invoke('video-search-layout', { refs });
+}
+
 async function videoSearchExportModel(name: string): Promise<{ success: boolean; outputDir: string }> {
   return window.diveDesktop.invoke('video-search-export-model', { name });
 }
@@ -1148,6 +1154,7 @@ export {
   videoSearchFormulate,
   videoSearchQuery,
   videoSearchRefine,
+  videoSearchLayout,
   videoSearchExportModel,
   videoSearchClose,
   videoSearchExtractFrame,
diff --git a/client/platform/desktop/frontend/components/QueryExemplar.vue b/client/platform/desktop/frontend/components/QueryExemplar.vue
index b392c9a1a..03337bfb9 100644
--- a/client/platform/desktop/frontend/components/QueryExemplar.vue
+++ b/client/platform/desktop/frontend/components/QueryExemplar.vue
@@ -100,20 +100,23 @@ export default defineComponent({
 
 <template>
   <div class="query-exemplar">
-    <img
-      ref="image"
-      :src="src"
-      class="exemplar-image"
-      draggable="false"
-      @pointerdown="onDown"
-      @pointermove="onMove"
-      @pointerup="onUp"
-      @pointercancel="onUp"
-    >
-    <div
-      class="exemplar-box"
-      :style="boxStyle()"
-    />
+    <!-- The box is placed by percentages of this frame, so it must hold the image alone -->
+    <div class="exemplar-frame">
+      <img
+        ref="image"
+        :src="src"
+        class="exemplar-image"
+        draggable="false"
+        @pointerdown="onDown"
+        @pointermove="onMove"
+        @pointerup="onUp"
+        @pointercancel="onUp"
+      >
+      <div
+        class="exemplar-box"
+        :style="boxStyle()"
+      />
+    </div>
     <div class="text-caption grey--text mt-1">
       {{ draft ? `Box ${draft.map(Math.round).join(', ')} (click to clear)` : 'Whole image; drag to mark one object' }}
     </div>
@@ -122,9 +125,15 @@ export default defineComponent({
 
 <style scoped>
 .query-exemplar {
+  display: inline-block;
+  max-width: 100%;
+}
+
+.exemplar-frame {
   position: relative;
   display: inline-block;
   max-width: 100%;
+  vertical-align: top;
 }
 
 .exemplar-image {
@@ -138,6 +147,7 @@ export default defineComponent({
 
 .exemplar-box {
   position: absolute;
+  box-sizing: border-box;
   border: 2px solid #00e5ff;
   background: rgba(0, 229, 255, 0.12);
   pointer-events: none;
diff --git a/client/platform/desktop/frontend/components/QueryPage.vue b/client/platform/desktop/frontend/components/QueryPage.vue
index 565143b42..cde6c002d 100644
--- a/client/platform/desktop/frontend/components/QueryPage.vue
+++ b/client/platform/desktop/frontend/components/QueryPage.vue
@@ -87,7 +87,9 @@ export default defineComponent({
       hidden: (result) => searchReview.isRemoved(result),
     });
     const textChips = resumed?.textChips ?? createItemChips(page.textItems);
-    const resultsMemory = resumed?.results ?? reactive({ page: 0, hideReviewed: false });
+    const resultsMemory = resumed?.results ?? reactive({
+      page: 0, hideReviewed: false, space: false, spaceCount: 25,
+    });
     const gridSettings = usePersistentGridSettings();
     const textGridActive = computed(() => view.value === 'query' && page.mode.value === 'text');
     const textGrid = useReviewGrid({
@@ -764,6 +766,9 @@ export default defineComponent({
                 :search-chips="searchChips"
                 :search-review="searchReview"
                 :memory="resultsMemory"
+                :exemplar-url="page.mode.value === 'video' ? videoFrameUrl : imageUrl"
+                :exemplar-box="page.mode.value === 'video'
+                  ? page.videoFrameBox.value : page.imageBox.value"
                 @open-result="openViewer"
                 @save-model="openSaveModel"
               />
diff --git a/client/platform/desktop/frontend/components/VideoSearchResultsGrid.spec.ts b/client/platform/desktop/frontend/components/VideoSearchResultsGrid.spec.ts
new file mode 100644
index 000000000..13d0cc4ba
--- /dev/null
+++ b/client/platform/desktop/frontend/components/VideoSearchResultsGrid.spec.ts
@@ -0,0 +1,170 @@
+// @vitest-environment jsdom
+import { shallowMount } from '@vue/test-utils';
+import {
+  computed, markRaw, reactive, ref,
+} from 'vue';
+import type { VueConstructor } from 'vue';
+import type { ReviewItem } from 'dive-common/review/types';
+import VideoSearchResultsGrid from './VideoSearchResultsGrid.vue';
+
+const mocks = vi.hoisted(() => ({ search: null as unknown }));
+vi.mock('../useVideoSearch', () => ({ useVideoSearch: () => mocks.search }));
+vi.mock('dive-common/vue-utilities/prompt-service', () => ({ usePrompt: () => ({ prompt: vi.fn() }) }));
+vi.mock('dive-common/use/useReview', () => ({ useReview: () => null }));
+vi.mock('vue-media-annotator/provides', () => ({ useHandler: () => null }));
+vi.mock('./VideoSearchResultsSpace.vue', () => ({
+  default: {
+    name: 'VideoSearchResultsSpace',
+    props: ['points', 'cells', 'exemplarUrl', 'exemplarBox', 'loading', 'error', 'missingCount', 'editable', 'typeOptions'],
+    render: (h: (tag: string) => unknown) => h('div'),
+  },
+}));
+
+function item(key: string, frame: number): ReviewItem {
+  return {
+    key,
+    datasetId: 'a',
+    trackId: frame,
+    primary: { frame, bounds: [0, 0, 10, 10] },
+    frames: [{ frame, bounds: [0, 0, 10, 10] }],
+    keyframeCount: 1,
+    type: '',
+    confidence: 1,
+  };
+}
+
+const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+function mount(refs: string[]) {
+  const results = refs.map((ref, i) => ({ ref, stream_id: 's', relevancy_score: 1 - i * 0.1 }));
+  const search = {
+    state: reactive({
+      results, adjudications: {} as Record<string, string>, busy: null, error: null, iteration: 0, queryGeneration: 1, modelAvailable: false,
+    }),
+    resultDatasetName: () => null,
+    resultIsLocal: () => true,
+    resultDatasetId: () => 'a',
+    mark: vi.fn(),
+    refine: vi.fn(),
+    layoutResults: vi.fn(async (wanted: string[]) => ({
+      success: true,
+      points: wanted.map((ref, i) => ({ ref, position: [i, 0, 0] as [number, number, number], distance: i * 2 })),
+      missing: [],
+    })),
+  };
+  mocks.search = search;
+  const items = computed(() => search.state.results.map((r, i) => item(r.ref, i)));
+  // Raw: the root instance would otherwise observe the prop and unwrap its refs.
+  const searchChips = markRaw({
+    items,
+    itemsByRef: computed(() => new Map(items.value.map((i) => [i.key, i]))),
+    chips: ref<Record<string, string>>({ [refs[0]]: 'data:chip' }),
+    tightChips: ref<Record<string, string>>({ [refs[0]]: 'data:tight' }),
+    tightStore: {
+      chips: ref({}),
+      ensurePrimary: vi.fn(),
+      reset: vi.fn(),
+    },
+    store: {
+      chips: ref({}),
+      sequences: ref({}),
+      transforms: ref({}),
+      sequenceTransforms: ref({}),
+      failures: ref({}),
+      ensurePrimary: vi.fn(),
+      ensureSequences: vi.fn(),
+      trimQueues: vi.fn(),
+      setOptions: vi.fn(),
+    },
+    dispose: vi.fn(),
+  });
+  const memory = reactive({
+    page: 0, hideReviewed: false, space: false, spaceCount: 2,
+  });
+  const wrapper = shallowMount(VideoSearchResultsGrid as unknown as VueConstructor, {
+    propsData: {
+      inline: true, searchChips, memory, exemplarUrl: 'file:///exemplar.jpg', exemplarBox: [10, 20, 110, 80],
+    },
+    stubs: ['v-card', 'v-toolbar', 'v-toolbar-title', 'v-btn', 'v-btn-toggle', 'v-icon', 'v-spacer', 'v-select', 'v-progress-linear', 'v-alert'],
+  });
+  return {
+    wrapper, search, searchChips, memory,
+  };
+}
+
+it('only places results in descriptor space once the 3D view is chosen, remembering the choice', async () => {
+  const {
+    wrapper, search, searchChips, memory,
+  } = mount(['0:1', '0:2', '0:3']);
+  await flush();
+  expect(search.layoutResults).not.toHaveBeenCalled();
+  expect(wrapper.findComponent({ name: 'VideoSearchResultsSpace' }).exists()).toBe(false);
+
+  (wrapper.vm as unknown as { space: boolean }).space = true;
+  await flush();
+  expect(search.layoutResults).toHaveBeenCalledWith(['0:1', '0:2']);
+  // The 3D view asks for its own chips, cropped to the box alone
+  expect(searchChips.tightStore.ensurePrimary).toHaveBeenCalledWith(expect.arrayContaining([expect.objectContaining({ key: '0:1' })]));
+  expect(searchChips.store.ensurePrimary).not.toHaveBeenCalled();
+  expect(memory).toMatchObject({ space: true, spaceCount: 2 });
+  const space = wrapper.findComponent({ name: 'VideoSearchResultsSpace' });
+  expect(space.exists()).toBe(true);
+  expect(space.props('points')).toEqual([
+    { key: '0:1', position: [0, 0, 0] }, { key: '0:2', position: [1, 0, 0] },
+  ]);
+  expect(space.props('cells')).toMatchObject([
+    {
+      key: '0:1', rank: 1, chip: 'data:tight', distance: 0, score: 1,
+    },
+    {
+      key: '0:2', rank: 2, chip: null, distance: 2,
+    },
+  ]);
+  expect(space.props('exemplarUrl')).toBe('file:///exemplar.jpg');
+  // The queried box goes along, so the center shows that part of the image alone
+  expect(space.props('exemplarBox')).toEqual([10, 20, 110, 80]);
+
+  (wrapper.vm as unknown as { spaceCount: number }).spaceCount = 3;
+  await flush();
+  expect(search.layoutResults).toHaveBeenLastCalledWith(['0:1', '0:2', '0:3']);
+  expect(memory.spaceCount).toBe(3);
+
+  // Refinement re-ranks under the same refs: the layout is fetched again.
+  search.state.results = [...search.state.results].reverse();
+  search.state.iteration = 1;
+  await flush();
+  expect(search.layoutResults).toHaveBeenLastCalledWith(['0:3', '0:2', '0:1']);
+  wrapper.destroy();
+});
+
+it('marks and opens results from the 3D view through the shared session', async () => {
+  const { wrapper, search } = mount(['0:1', '0:2']);
+  (wrapper.vm as unknown as { space: boolean }).space = true;
+  await flush();
+  const space = wrapper.findComponent({ name: 'VideoSearchResultsSpace' });
+  space.vm.$emit('mark', ['0:2'], 'negative');
+  expect(search.mark).toHaveBeenCalledWith('0:2', 'negative');
+  space.vm.$emit('open', '0:2');
+  expect(wrapper.emitted('open-result')?.[0]).toEqual(['a', 1, undefined]);
+  wrapper.destroy();
+});
+
+it('sets a mark on every selected result, leaving alone those that already carry it', async () => {
+  const { wrapper, search } = mount(['0:1', '0:2', '0:3']);
+  (wrapper.vm as unknown as { space: boolean; spaceCount: number }).spaceCount = 3;
+  (wrapper.vm as unknown as { space: boolean }).space = true;
+  search.state.adjudications = { '0:2': 'positive' };
+  await flush();
+  const space = wrapper.findComponent({ name: 'VideoSearchResultsSpace' });
+  // A mark toggles, so marking '0:2' again would have cleared it
+  space.vm.$emit('mark', ['0:1', '0:2', '0:3'], 'positive');
+  expect(search.mark.mock.calls).toEqual([['0:1', 'positive'], ['0:3', 'positive']]);
+  wrapper.destroy();
+});
+
+it('offers up to a thousand results in the 3D view', () => {
+  const { wrapper } = mount(['0:1']);
+  expect((wrapper.vm as unknown as { spaceCountChoices: number[] }).spaceCountChoices)
+    .toEqual([10, 25, 50, 100, 250, 1000]);
+  wrapper.destroy();
+});
diff --git a/client/platform/desktop/frontend/components/VideoSearchResultsGrid.vue b/client/platform/desktop/frontend/components/VideoSearchResultsGrid.vue
index 29c06b8d2..5ca0251c2 100644
--- a/client/platform/desktop/frontend/components/VideoSearchResultsGrid.vue
+++ b/client/platform/desktop/frontend/components/VideoSearchResultsGrid.vue
@@ -1,6 +1,6 @@
 <script lang="ts">
 import {
-  computed, defineComponent, onBeforeUnmount, PropType, ref, watch,
+  computed, defineComponent, onBeforeUnmount, PropType, ref, shallowRef, watch,
 } from 'vue';
 import { useHandler } from 'vue-media-annotator/provides';
 import { usePrompt } from 'dive-common/vue-utilities/prompt-service';
@@ -13,13 +13,18 @@ import type { ReviewService } from 'dive-common/use/useReview';
 import { usePersistentGridSettings } from 'dive-common/review/gridSettings';
 import { useReviewGrid } from 'dive-common/review/useReviewGrid';
 import type { ReviewItem } from 'dive-common/review/types';
-import type { VideoSearchResult } from 'dive-common/apispec';
+import type { VideoSearchLayoutResponse, VideoSearchResult } from 'dive-common/apispec';
+import type { SpacePoint } from 'platform/desktop/frontend/resultSpace';
 import ReviewGrid from 'dive-common/components/Review/ReviewGrid.vue';
 import ReviewGridControls from 'dive-common/components/Review/ReviewGridControls.vue';
 import ReviewCell, { ReviewCellGeometryEdit } from 'dive-common/components/Review/ReviewCell.vue';
+import VideoSearchResultsSpace, { SpaceCell } from './VideoSearchResultsSpace.vue';
 
 /** Footer height of a search cell (type field and caption), for the chip aspect ratio. */
 const SearchCellFooterPx = 48;
+/** How many top results the 3D view may place. */
+const SpaceCountChoices = [10, 25, 50, 100, 250, 1000];
+const DefaultSpaceCount = 25;
 
 /**
  * Full-window review grid of ranked search results across every indexed
@@ -28,10 +33,14 @@ const SearchCellFooterPx = 48;
  * panel, and the grid shape, zoom, context and paging with the Review page.
  * With a search review attached, cells are also editable annotations:
  * typing a type or adjusting a box adopts the result into its dataset.
+ * An optional 3D view places the top results around the query in
+ * descriptor space instead of the grid.
  */
 export default defineComponent({
   name: 'VideoSearchResultsGrid',
-  components: { ReviewGrid, ReviewGridControls, ReviewCell },
+  components: {
+    ReviewGrid, ReviewGridControls, ReviewCell, VideoSearchResultsSpace,
+  },
   props: {
     value: {
       type: Boolean,
@@ -59,6 +68,16 @@ export default defineComponent({
       type: Object as PropType<ResultsGridMemory | null>,
       default: null,
     },
+    /** Image of the query exemplar, shown at the center of the 3D view. */
+    exemplarUrl: {
+      type: String,
+      default: '',
+    },
+    /** The box queried within that image; the 3D view shows just this part of it. */
+    exemplarBox: {
+      type: Array as unknown as PropType<[number, number, number, number] | null>,
+      default: null,
+    },
   },
   setup(props, { emit }) {
     const search = useVideoSearch();
@@ -92,10 +111,81 @@ export default defineComponent({
       retainPage: true,
     });
     watch(() => state.value?.queryGeneration, () => grid.goToPage(0));
+
+    // ---- 3D descriptor-space view ----------------------------------------
+    const space = ref(props.memory?.space ?? false);
+    const spaceCount = ref(props.memory?.spaceCount ?? DefaultSpaceCount);
+    const spaceItems = computed(() => (space.value ? visibleItems.value.slice(0, spaceCount.value) : []));
+    const spaceLayout = shallowRef<VideoSearchLayoutResponse | null>(null);
+    const spaceLoading = ref(false);
+    const spaceError = ref('');
+    let spaceRequest = 0;
+    // Refs are only comparable within a query generation; refinement
+    // re-ranks, so the same refs in a new order still need a new layout.
+    watch([
+      () => state.value?.queryGeneration,
+      () => state.value?.iteration,
+      () => spaceItems.value.map((item) => item.key).join('\n'),
+    ], async ([, , keys]) => {
+      spaceRequest += 1;
+      const request = spaceRequest;
+      const refs = keys ? keys.split('\n') : [];
+      if (!search || !refs.length) {
+        spaceLayout.value = null;
+        spaceLoading.value = false;
+        return;
+      }
+      props.searchChips.tightStore.ensurePrimary(spaceItems.value);
+      spaceLoading.value = true;
+      spaceError.value = '';
+      try {
+        const layout = await search.layoutResults(refs);
+        if (request === spaceRequest) spaceLayout.value = layout;
+      } catch (err) {
+        if (request === spaceRequest) {
+          spaceLayout.value = null;
+          spaceError.value = err instanceof Error ? err.message : String(err);
+        }
+      } finally {
+        if (request === spaceRequest) spaceLoading.value = false;
+      }
+    }, { immediate: true });
+
+    const spacePoints = computed<SpacePoint[]>(() => (spaceLayout.value?.points ?? [])
+      .map((point) => ({ key: point.ref, position: point.position })));
+    const spaceCells = computed<SpaceCell[]>(() => {
+      // Read so type changes and deletions re-render, as in the grid's cells
+      const revision = review?.dataRevision.value ?? 0;
+      const distances = new Map((spaceLayout.value?.points ?? []).map((point) => [point.ref, point.distance]));
+      return spaceItems.value.map((item, index): SpaceCell => {
+        const result = resultsByRef.value.get(item.key);
+        const datasetName = search && result ? search.resultDatasetName(result) : null;
+        const adopted = result && props.searchReview
+          ? props.searchReview.itemOf(result) : undefined;
+        return {
+          key: item.key,
+          rank: index + 1,
+          // Cropped to the box alone; the grid's chips carry context around it
+          chip: props.searchChips.tightChips.value[item.key] || null,
+          revision,
+          type: (adopted && review ? review.currentType(adopted)?.type : '') ?? '',
+          adopted: adopted !== undefined,
+          adjudication: (result && adjudications.value[result.ref]) || '',
+          title: `${datasetName || 'This dataset'} · frame ${item.primary.frame}`,
+          subtitle: [`Frame ${item.primary.frame}`, datasetName].filter(Boolean).join(' · '),
+          score: result?.relevancy_score ?? 0,
+          distance: distances.get(item.key) ?? 0,
+        };
+      });
+    });
+    const spaceMissingCount = computed(() => spaceLayout.value?.missing?.length ?? 0);
+
     if (props.memory) {
       grid.goToPage(props.memory.page);
-      watch([grid.page, hideReviewed], ([page, hide]) => {
-        Object.assign(props.memory as ResultsGridMemory, { page, hideReviewed: hide });
+      watch([grid.page, hideReviewed, space, spaceCount], ([page, hide, inSpace, count]) => {
+        Object.assign(props.memory as ResultsGridMemory, {
+          page, hideReviewed: hide, space: inSpace, spaceCount: count,
+        });
       });
     }
 
@@ -151,7 +241,7 @@ export default defineComponent({
       // Swallow paging keys before they bubble to document, where the
       // annotator's mousetrap left/right bindings would seek the (hidden)
       // playhead one frame per grid page turn.
-      if (grid.handleKeydown(event)) {
+      if (!space.value && grid.handleKeydown(event)) {
         event.stopPropagation();
       }
     }
@@ -187,6 +277,30 @@ export default defineComponent({
       search?.mark(item.key, adjudication);
     }
 
+    function openSpaceItem(key: string) {
+      const item = props.searchChips.itemsByRef.value.get(key);
+      if (item) openItem(item);
+    }
+
+    /** One result toggles its mark, as in the grid; several are all set to it. */
+    function markSpaceItems(keys: string[], adjudication: 'positive' | 'negative') {
+      if (!search) return;
+      if (keys.length === 1) {
+        search.mark(keys[0], adjudication);
+        return;
+      }
+      keys.filter((key) => adjudications.value[key] !== adjudication)
+        .forEach((key) => search.mark(key, adjudication));
+    }
+
+    function assignSpaceItems(keys: string[], type: string) {
+      keys.forEach((key) => assign(resultsByRef.value.get(key), type));
+    }
+
+    function removeSpaceItems(keys: string[]) {
+      keys.forEach((key) => remove(resultsByRef.value.get(key)));
+    }
+
     function assign(result: VideoSearchResult | undefined, type: string) {
       if (result && props.searchReview) props.searchReview.assignType(result, type);
     }
@@ -234,6 +348,18 @@ export default defineComponent({
       reviewedCount,
       annotationHasChanges,
       annotationChangeCount,
+      space,
+      spaceCount,
+      spaceCountChoices: SpaceCountChoices,
+      spacePoints,
+      spaceCells,
+      spaceLoading,
+      spaceError,
+      spaceMissingCount,
+      openSpaceItem,
+      markSpaceItems,
+      assignSpaceItems,
+      removeSpaceItems,
       close,
       openItem,
       mark,
@@ -271,6 +397,32 @@ export default defineComponent({
         <v-toolbar-title class="text-subtitle-1">
           Search Results
         </v-toolbar-title>
+        <v-btn-toggle
+          :value="space ? 'space' : 'grid'"
+          mandatory
+          dense
+          class="ml-4"
+          @change="space = $event === 'space'"
+        >
+          <v-btn
+            small
+            value="grid"
+            title="Ranked chip grid"
+          >
+            <v-icon small>
+              mdi-view-grid-outline
+            </v-icon>
+          </v-btn>
+          <v-btn
+            small
+            value="space"
+            title="Top results around the query in 3D descriptor space"
+          >
+            <v-icon small>
+              mdi-cube-outline
+            </v-icon>
+          </v-btn>
+        </v-btn-toggle>
         <v-spacer />
         <span class="text-caption mr-3">
           <v-icon
@@ -355,7 +507,49 @@ export default defineComponent({
         </v-btn>
       </v-toolbar>
 
+      <div
+        v-if="space"
+        class="d-flex align-center px-2 py-1 flex-grow-0"
+      >
+        <span class="text-caption mr-3">{{ countLabel }}</span>
+        <v-select
+          :value="spaceCount"
+          :items="spaceCountChoices"
+          label="Results shown"
+          dense
+          outlined
+          hide-details
+          class="space-count"
+          @change="spaceCount = $event"
+        />
+        <v-btn
+          small
+          :text="!hideReviewed"
+          :outlined="hideReviewed"
+          :color="hideReviewed ? 'primary' : undefined"
+          class="ml-2"
+          title="Hide the results already marked correct or incorrect"
+          @click="hideReviewed = !hideReviewed"
+        >
+          <v-icon
+            small
+            left
+          >
+            {{ hideReviewed ? 'mdi-eye-off' : 'mdi-eye-off-outline' }}
+          </v-icon>
+          Hide reviewed
+          <span
+            v-if="reviewedCount"
+            class="ml-1 grey--text"
+          >({{ reviewedCount }})</span>
+        </v-btn>
+        <v-spacer />
+        <span class="text-caption grey--text">
+          Drag to orbit · middle drag to slide · wheel to zoom · shift drag to select
+        </span>
+      </div>
       <ReviewGridControls
+        v-else
         :grid="gridSettings"
         :page="grid.page.value"
         :page-count="grid.pageCount.value"
@@ -429,7 +623,27 @@ export default defineComponent({
       </v-alert>
 
       <div
-        v-if="!cells.length"
+        v-if="space"
+        class="results-grid-body flex-grow-1"
+      >
+        <VideoSearchResultsSpace
+          :points="spacePoints"
+          :cells="spaceCells"
+          :exemplar-url="exemplarUrl"
+          :exemplar-box="exemplarBox"
+          :loading="spaceLoading"
+          :error="spaceError"
+          :missing-count="spaceMissingCount"
+          :editable="!!searchReview"
+          :type-options="review ? review.knownTypes.value : []"
+          @open="openSpaceItem"
+          @mark="markSpaceItems"
+          @assign="assignSpaceItems"
+          @remove="removeSpaceItems"
+        />
+      </div>
+      <div
+        v-else-if="!cells.length"
         class="d-flex align-center justify-center flex-grow-1 grey--text"
       >
         {{ results.length && hideReviewed ? 'Every result has been reviewed.' : 'No search results to review.' }}
@@ -550,4 +764,7 @@ export default defineComponent({
   min-height: 0;
   overflow: hidden;
 }
+.space-count {
+  max-width: 160px;
+}
 </style>
diff --git a/client/platform/desktop/frontend/components/VideoSearchResultsSpace.vue b/client/platform/desktop/frontend/components/VideoSearchResultsSpace.vue
new file mode 100644
index 000000000..7aaff070f
--- /dev/null
+++ b/client/platform/desktop/frontend/components/VideoSearchResultsSpace.vue
@@ -0,0 +1,788 @@
+<script lang="ts">
+import {
+  computed, defineComponent, onBeforeUnmount, onMounted, PropType, ref, shallowRef, watch,
+} from 'vue';
+import {
+  billboardHalfSize, DEFAULT_ORBIT, normalizePositions, orbitDrag, orbitPan, orbitZoom,
+  paintOrder, pick, pickInBox, project,
+  CanvasBox, Orbit, Projected, SpacePoint,
+} from 'platform/desktop/frontend/resultSpace';
+import ReviewTypeField from 'dive-common/components/Review/ReviewTypeField.vue';
+
+/** What the view knows about one placed result. */
+export interface SpaceCell {
+  key: string;
+  /** 1-based rank in the result list. */
+  rank: number;
+  /** Rendered chip (data URL), once loaded. */
+  chip: string | null;
+  adjudication: '' | 'positive' | 'negative';
+  title: string;
+  subtitle: string;
+  score: number;
+  /** Descriptor distance from the query. */
+  distance: number;
+  /** Annotation type, once the result has been taken up as an annotation. */
+  type: string;
+  /** Whether the result is an annotation that can be deleted. */
+  adopted: boolean;
+  /** Moves on when annotations are edited, so the cells are rebuilt. */
+  revision: number;
+}
+
+type Adjudication = 'positive' | 'negative';
+/** How a billboard departs from a square showing its whole image. */
+interface Appearance {
+  /** Half width and half height, as fractions of the billboard's half size. */
+  shape?: [number, number];
+  /** The part of the image to show: x, y, width and height in its pixels. */
+  crop?: [number, number, number, number];
+}
+/** What a press of the mouse is doing until it is released. */
+type Gesture = 'orbit' | 'pan' | 'box' | null;
+
+/** Billboard half-size in canvas pixels at scale 1, and the least it shrinks to. */
+const HALF_SIZE = 26;
+const SMALLEST_HALF_SIZE = 8;
+const EXEMPLAR_HALF_SIZE = 34;
+const COLORS = {
+  background: '#121212',
+  axis: 'rgba(255, 255, 255, 0.08)',
+  line: 'rgba(255, 255, 255, 0.28)',
+  positive: '#4caf50',
+  negative: '#ff5252',
+  neutral: 'rgba(255, 255, 255, 0.55)',
+  exemplar: '#ffc107',
+  focus: '#00e5ff',
+  label: 'rgba(0, 0, 0, 0.7)',
+  box: 'rgba(0, 229, 255, 0.9)',
+  boxFill: 'rgba(0, 229, 255, 0.12)',
+};
+/** Idle rotation speed while auto-spin is on. */
+const SPIN_RADIANS_PER_MS = 0.00025;
+
+/**
+ * Results as chips floating around the query in 3D descriptor space, each
+ * tied to the query by a line; nearer chips are more similar. Drag orbits,
+ * a middle drag slides the view, the wheel zooms, hovering names a result,
+ * clicking selects it for marking, double clicking opens it. A box drawn
+ * with shift held (or with the box tool on) selects every result it
+ * touches, to mark, retype or delete together.
+ */
+export default defineComponent({
+  name: 'VideoSearchResultsSpace',
+  components: { ReviewTypeField },
+  props: {
+    points: {
+      type: Array as PropType<SpacePoint[]>,
+      required: true,
+    },
+    cells: {
+      type: Array as PropType<SpaceCell[]>,
+      required: true,
+    },
+    /** Image of the query exemplar for the center marker. */
+    exemplarUrl: {
+      type: String,
+      default: '',
+    },
+    /** The box queried within that image, in its pixels; the whole image when absent. */
+    exemplarBox: {
+      type: Array as unknown as PropType<[number, number, number, number] | null>,
+      default: null,
+    },
+    loading: {
+      type: Boolean,
+      default: false,
+    },
+    /** Results that could not be placed (no stored descriptor). */
+    missingCount: {
+      type: Number,
+      default: 0,
+    },
+    error: {
+      type: String,
+      default: '',
+    },
+    /** Whether results can be given a type and deleted as annotations. */
+    editable: {
+      type: Boolean,
+      default: false,
+    },
+    typeOptions: {
+      type: Array as PropType<string[]>,
+      default: () => [],
+    },
+  },
+  setup(props, { emit }) {
+    const container = ref<HTMLDivElement | null>(null);
+    const canvas = ref<HTMLCanvasElement | null>(null);
+    const orbit = ref<Orbit>({ ...DEFAULT_ORBIT });
+    const spin = ref(false);
+    const hovered = ref<string | null>(null);
+    const selected = ref<string[]>([]);
+    const selectedSet = computed(() => new Set(selected.value));
+    const boxTool = ref(false);
+    const drawnBox = ref<CanvasBox | null>(null);
+    const cursor = ref({ x: 0, y: 0 });
+    const size = ref({ width: 0, height: 0 });
+
+    const cellsByKey = computed(() => new Map(props.cells.map((cell) => [cell.key, cell])));
+    const halfSize = computed(() => billboardHalfSize(
+      props.points.length,
+      HALF_SIZE,
+      SMALLEST_HALF_SIZE,
+    ));
+    const normalized = computed(() => normalizePositions(props.points));
+    const projected = shallowRef<Projected[]>([]);
+
+    const images = new Map<string, HTMLImageElement>();
+    function imageFor(src: string): HTMLImageElement | null {
+      const cached = images.get(src);
+      if (cached) return cached.complete && cached.naturalWidth > 0 ? cached : null;
+      const image = new Image();
+      image.onload = () => requestDraw();
+      image.src = src;
+      images.set(src, image);
+      return null;
+    }
+
+    let frame = 0;
+    let lastTick = 0;
+    function requestDraw() {
+      if (frame) return;
+      frame = window.requestAnimationFrame((now) => {
+        frame = 0;
+        if (spin.value && !gesture) {
+          const elapsed = lastTick ? now - lastTick : 0;
+          orbit.value = { ...orbit.value, yaw: orbit.value.yaw + elapsed * SPIN_RADIANS_PER_MS };
+        }
+        lastTick = now;
+        draw();
+        if (spin.value) requestDraw();
+      });
+    }
+
+    function strokeFor(cell: SpaceCell | undefined, focused: boolean): string {
+      if (focused) return COLORS.focus;
+      if (cell?.adjudication === 'positive') return COLORS.positive;
+      if (cell?.adjudication === 'negative') return COLORS.negative;
+      return COLORS.neutral;
+    }
+
+    /**
+     * Chips are cropped to their box, so each billboard takes its chip's
+     * shape: the longer side spans the full size, the other in proportion.
+     */
+    function shapeOf(key: string): [number, number] {
+      const src = cellsByKey.value.get(key)?.chip;
+      const image = src ? images.get(src) : undefined;
+      if (!image || !image.naturalWidth || !image.naturalHeight) return [1, 1];
+      const longest = Math.max(image.naturalWidth, image.naturalHeight);
+      return [image.naturalWidth / longest, image.naturalHeight / longest];
+    }
+
+    /**
+     * What to show of the exemplar: the queried box when there is one, the
+     * whole image otherwise, at its own shape either way.
+     */
+    function exemplarView(): Appearance {
+      const image = props.exemplarUrl ? images.get(props.exemplarUrl) : undefined;
+      const box = props.exemplarBox;
+      let [width, height] = [image?.naturalWidth ?? 0, image?.naturalHeight ?? 0];
+      let crop: [number, number, number, number] | undefined;
+      if (box && width && height) {
+        const [x1, y1] = [Math.max(0, Math.min(box[0], box[2])), Math.max(0, Math.min(box[1], box[3]))];
+        const [x2, y2] = [
+          Math.min(width, Math.max(box[0], box[2])), Math.min(height, Math.max(box[1], box[3])),
+        ];
+        if (x2 > x1 && y2 > y1) {
+          crop = [x1, y1, x2 - x1, y2 - y1];
+          [width, height] = [x2 - x1, y2 - y1];
+        }
+      }
+      if (!width || !height) return { shape: [1, 1] };
+      const longest = Math.max(width, height);
+      return { crop, shape: [width / longest, height / longest] };
+    }
+
+    function drawBillboard(
+      ctx: CanvasRenderingContext2D,
+      p: { x: number; y: number; scale: number },
+      half: number,
+      src: string | null,
+      stroke: string,
+      lineWidth: number,
+      { label, shape = [1, 1], crop }: Appearance & { label?: string } = {},
+    ) {
+      const w = half * p.scale * shape[0];
+      const h = half * p.scale * shape[1];
+      const image = src ? imageFor(src) : null;
+      ctx.save();
+      if (image && crop) {
+        ctx.drawImage(image, ...crop, p.x - w, p.y - h, 2 * w, 2 * h);
+      } else if (image) {
+        ctx.drawImage(image, p.x - w, p.y - h, 2 * w, 2 * h);
+      } else {
+        ctx.fillStyle = 'rgba(255, 255, 255, 0.12)';
+        ctx.fillRect(p.x - w, p.y - h, 2 * w, 2 * h);
+      }
+      ctx.strokeStyle = stroke;
+      ctx.lineWidth = lineWidth;
+      ctx.strokeRect(p.x - w, p.y - h, 2 * w, 2 * h);
+      if (label && half * p.scale >= 14) {
+        ctx.font = `${Math.max(9, Math.round(10 * p.scale))}px sans-serif`;
+        const width = ctx.measureText(label).width + 6;
+        ctx.fillStyle = COLORS.label;
+        ctx.fillRect(p.x - w, p.y - h, width, 13 * Math.max(0.8, p.scale));
+        ctx.fillStyle = '#fff';
+        ctx.textBaseline = 'top';
+        ctx.fillText(label, p.x - w + 3, p.y - h + 2);
+      }
+      ctx.restore();
+    }
+
+    function draw() {
+      const el = canvas.value;
+      const { width, height } = size.value;
+      if (!el || !width || !height) return;
+      const dpr = window.devicePixelRatio || 1;
+      if (el.width !== Math.round(width * dpr) || el.height !== Math.round(height * dpr)) {
+        el.width = Math.round(width * dpr);
+        el.height = Math.round(height * dpr);
+      }
+      const ctx = el.getContext('2d');
+      if (!ctx) return;
+      ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+      ctx.fillStyle = COLORS.background;
+      ctx.fillRect(0, 0, width, height);
+
+      const viewport = { width, height };
+      const [center] = project([{ key: '', position: [0, 0, 0] }], orbit.value, viewport);
+      const axisEnds = project([
+        { key: 'x', position: [1, 0, 0] }, { key: '-x', position: [-1, 0, 0] },
+        { key: 'y', position: [0, 1, 0] }, { key: '-y', position: [0, -1, 0] },
+        { key: 'z', position: [0, 0, 1] }, { key: '-z', position: [0, 0, -1] },
+      ], orbit.value, viewport);
+      const isFocused = (key: string) => key === hovered.value || selectedSet.value.has(key);
+      const drawExemplar = () => {
+        drawBillboard(
+          ctx,
+          center,
+          EXEMPLAR_HALF_SIZE,
+          props.exemplarUrl || null,
+          COLORS.exemplar,
+          2,
+          { label: 'Query', ...exemplarView() },
+        );
+      };
+      ctx.strokeStyle = COLORS.axis;
+      ctx.lineWidth = 1;
+      for (let i = 0; i < axisEnds.length; i += 2) {
+        ctx.beginPath();
+        ctx.moveTo(axisEnds[i].x, axisEnds[i].y);
+        ctx.lineTo(axisEnds[i + 1].x, axisEnds[i + 1].y);
+        ctx.stroke();
+      }
+
+      const ordered = paintOrder(project(normalized.value, orbit.value, viewport));
+      projected.value = ordered;
+      ordered.forEach((p) => {
+        const cell = cellsByKey.value.get(p.key);
+        const focused = isFocused(p.key);
+        ctx.strokeStyle = focused || cell?.adjudication ? strokeFor(cell, focused) : COLORS.line;
+        ctx.lineWidth = focused ? 2 : 1;
+        ctx.globalAlpha = focused ? 1 : Math.min(1, 0.35 + p.scale * 0.5);
+        ctx.beginPath();
+        ctx.moveTo(center.x, center.y);
+        ctx.lineTo(p.x, p.y);
+        ctx.stroke();
+      });
+      ctx.globalAlpha = 1;
+
+      // The exemplar paints in depth order with the results (it sits at the origin).
+      let exemplarDrawn = false;
+      ordered.forEach((p) => {
+        if (!exemplarDrawn && p.depth <= center.depth) {
+          drawExemplar();
+          exemplarDrawn = true;
+        }
+        const cell = cellsByKey.value.get(p.key);
+        const focused = isFocused(p.key);
+        drawBillboard(
+          ctx,
+          p,
+          halfSize.value,
+          cell?.chip ?? null,
+          strokeFor(cell, focused),
+          focused ? 3 : 1.5,
+          { label: cell ? `#${cell.rank}` : undefined, shape: shapeOf(p.key) },
+        );
+      });
+      if (!exemplarDrawn) {
+        drawExemplar();
+      }
+
+      const box = drawnBox.value;
+      if (box) {
+        const [x, y] = [Math.min(box.x1, box.x2), Math.min(box.y1, box.y2)];
+        const [w, h] = [Math.abs(box.x2 - box.x1), Math.abs(box.y2 - box.y1)];
+        ctx.fillStyle = COLORS.boxFill;
+        ctx.fillRect(x, y, w, h);
+        ctx.strokeStyle = COLORS.box;
+        ctx.lineWidth = 1;
+        ctx.setLineDash([4, 3]);
+        ctx.strokeRect(x, y, w, h);
+        ctx.setLineDash([]);
+      }
+    }
+
+    // ---- interaction ------------------------------------------------------
+
+    let gesture: Gesture = null;
+    let dragMoved = false;
+    let last = { x: 0, y: 0 };
+
+    function localPoint(event: MouseEvent) {
+      const rect = canvas.value?.getBoundingClientRect();
+      return { x: event.clientX - (rect?.left ?? 0), y: event.clientY - (rect?.top ?? 0) };
+    }
+
+    function hitAt(x: number, y: number) {
+      return pick(projected.value, x, y, halfSize.value, shapeOf);
+    }
+
+    function onMouseDown(event: MouseEvent) {
+      if (event.button === 1) {
+        // Keep the browser from starting its own middle-button scroll
+        event.preventDefault();
+        gesture = 'pan';
+      } else if (event.button === 0) {
+        gesture = boxTool.value || event.shiftKey ? 'box' : 'orbit';
+      } else {
+        return;
+      }
+      dragMoved = false;
+      last = { x: event.clientX, y: event.clientY };
+      if (gesture === 'box') {
+        const { x, y } = localPoint(event);
+        drawnBox.value = {
+          x1: x, y1: y, x2: x, y2: y,
+        };
+      }
+    }
+
+    function onMouseMove(event: MouseEvent) {
+      cursor.value = localPoint(event);
+      if (gesture) {
+        const dx = event.clientX - last.x;
+        const dy = event.clientY - last.y;
+        if (Math.abs(dx) + Math.abs(dy) > 2) dragMoved = true;
+        last = { x: event.clientX, y: event.clientY };
+        if (gesture === 'pan') {
+          orbit.value = orbitPan(orbit.value, dx, dy);
+        } else if (gesture === 'orbit') {
+          orbit.value = orbitDrag(orbit.value, dx, dy);
+        } else if (drawnBox.value) {
+          drawnBox.value = { ...drawnBox.value, x2: cursor.value.x, y2: cursor.value.y };
+        }
+        return;
+      }
+      hovered.value = hitAt(cursor.value.x, cursor.value.y)?.key ?? null;
+    }
+
+    function onMouseUp(event: MouseEvent) {
+      const finished = gesture;
+      const box = drawnBox.value;
+      gesture = null;
+      drawnBox.value = null;
+      if (!finished || finished === 'pan') return;
+      if (finished === 'box' && box && dragMoved) {
+        selected.value = pickInBox(projected.value, box, halfSize.value, shapeOf);
+        return;
+      }
+      if (dragMoved) return;
+      const { x, y } = localPoint(event);
+      const hit = hitAt(x, y)?.key ?? null;
+      if (event.shiftKey && hit) {
+        // Shift adds to, or takes from, what is already selected
+        selected.value = selectedSet.value.has(hit)
+          ? selected.value.filter((key) => key !== hit) : [...selected.value, hit];
+      } else {
+        selected.value = hit ? [hit] : [];
+      }
+    }
+
+    function onMouseLeave() {
+      hovered.value = null;
+      gesture = null;
+      drawnBox.value = null;
+    }
+
+    function onDoubleClick(event: MouseEvent) {
+      const { x, y } = localPoint(event);
+      const hit = hitAt(x, y);
+      if (hit) emit('open', hit.key);
+    }
+
+    function onWheel(event: WheelEvent) {
+      event.preventDefault();
+      orbit.value = orbitZoom(orbit.value, event.deltaY);
+    }
+
+    /** Back to the opening view: the query centered, at the opening angle and zoom. */
+    function resetView() {
+      orbit.value = { ...DEFAULT_ORBIT };
+    }
+
+    const selectedCells = computed(() => selected.value
+      .map((key) => cellsByKey.value.get(key))
+      .filter((cell): cell is SpaceCell => cell !== undefined));
+    /** The type the selection shares, or none when it is mixed. */
+    const selectedType = computed(() => {
+      const types = new Set(selectedCells.value.map((cell) => cell.type));
+      return types.size === 1 ? [...types][0] : '';
+    });
+    const selectedAdopted = computed(() => selectedCells.value.filter((cell) => cell.adopted));
+    /** Whether every selected result already carries this mark. */
+    function allMarked(adjudication: Adjudication) {
+      return selectedCells.value.length > 0
+        && selectedCells.value.every((cell) => cell.adjudication === adjudication);
+    }
+    function markSelected(adjudication: Adjudication) {
+      emit('mark', selectedCells.value.map((cell) => cell.key), adjudication);
+    }
+    function assignSelected(type: string) {
+      emit('assign', selectedCells.value.map((cell) => cell.key), type);
+    }
+    function removeSelected() {
+      emit('remove', selectedAdopted.value.map((cell) => cell.key));
+      selected.value = [];
+    }
+
+    const selectedCell = computed(() => (selectedCells.value.length === 1
+      ? selectedCells.value[0] : null));
+    const hoveredCell = computed(() => (hovered.value && !selectedSet.value.has(hovered.value)
+      ? cellsByKey.value.get(hovered.value) ?? null : null));
+    const tooltipStyle = computed(() => ({
+      left: `${Math.min(cursor.value.x + 14, Math.max(0, size.value.width - 220))}px`,
+      top: `${Math.min(cursor.value.y + 14, Math.max(0, size.value.height - 60))}px`,
+    }));
+
+    watch([
+      orbit, hovered, selected, drawnBox, normalized, () => props.cells, () => props.exemplarUrl,
+      () => props.exemplarBox,
+    ], () => requestDraw(), { deep: true });
+    watch(spin, (on) => {
+      lastTick = 0;
+      if (on) requestDraw();
+    });
+    watch(() => props.points, () => {
+      const placed = new Set(props.points.map((p) => p.key));
+      if (selected.value.some((key) => !placed.has(key))) {
+        selected.value = selected.value.filter((key) => placed.has(key));
+      }
+    });
+
+    let observer: ResizeObserver | null = null;
+    onMounted(() => {
+      const el = container.value;
+      if (!el) return;
+      const measure = () => {
+        size.value = { width: el.clientWidth, height: el.clientHeight };
+        requestDraw();
+      };
+      if (typeof ResizeObserver !== 'undefined') {
+        observer = new ResizeObserver(measure);
+        observer.observe(el);
+      }
+      measure();
+    });
+    onBeforeUnmount(() => {
+      observer?.disconnect();
+      if (frame) window.cancelAnimationFrame(frame);
+      images.clear();
+    });
+
+    return {
+      container,
+      canvas,
+      spin,
+      boxTool,
+      selected,
+      selectedCell,
+      selectedCells,
+      selectedType,
+      selectedAdopted,
+      allMarked,
+      markSelected,
+      assignSelected,
+      removeSelected,
+      hoveredCell,
+      tooltipStyle,
+      onMouseDown,
+      onMouseMove,
+      onMouseUp,
+      onMouseLeave,
+      onDoubleClick,
+      onWheel,
+      resetView,
+    };
+  },
+});
+</script>
+
+<template>
+  <div
+    ref="container"
+    class="results-space"
+  >
+    <canvas
+      ref="canvas"
+      class="results-space-canvas"
+      :class="{ 'results-space-hover': hoveredCell, 'results-space-box': boxTool }"
+      @mousedown="onMouseDown"
+      @mousemove="onMouseMove"
+      @mouseup="onMouseUp"
+      @mouseleave="onMouseLeave"
+      @dblclick="onDoubleClick"
+      @wheel="onWheel"
+    />
+    <div class="results-space-tools">
+      <v-btn
+        icon
+        small
+        title="Reset the view: center the query and undo any turn, slide or zoom"
+        @click="resetView"
+      >
+        <v-icon small>
+          mdi-image-filter-center-focus
+        </v-icon>
+      </v-btn>
+      <v-btn
+        icon
+        small
+        :color="boxTool ? 'primary' : undefined"
+        title="Draw a box to select every result it touches (or hold shift and drag)"
+        @click="boxTool = !boxTool"
+      >
+        <v-icon small>
+          mdi-select-drag
+        </v-icon>
+      </v-btn>
+      <v-btn
+        icon
+        small
+        :color="spin ? 'primary' : undefined"
+        title="Slowly rotate the view"
+        @click="spin = !spin"
+      >
+        <v-icon small>
+          mdi-rotate-3d
+        </v-icon>
+      </v-btn>
+    </div>
+    <div
+      v-if="hoveredCell"
+      class="results-space-tooltip text-caption"
+      :style="tooltipStyle"
+    >
+      <div>#{{ hoveredCell.rank }} · {{ hoveredCell.title }}</div>
+      <div class="grey--text">
+        score {{ hoveredCell.score.toFixed(3) }} · distance {{ hoveredCell.distance.toFixed(2) }}
+      </div>
+    </div>
+    <v-card
+      v-if="selectedCells.length"
+      class="results-space-selected pa-2"
+      outlined
+    >
+      <div class="d-flex align-center">
+        <img
+          v-if="selectedCell && selectedCell.chip"
+          :src="selectedCell.chip"
+          class="results-space-selected-chip mr-2"
+        >
+        <div
+          v-if="selectedCell"
+          class="text-caption flex-grow-1"
+        >
+          <div>#{{ selectedCell.rank }} · {{ selectedCell.subtitle }}</div>
+          <div class="grey--text">
+            score {{ selectedCell.score.toFixed(3) }} · distance {{ selectedCell.distance.toFixed(2) }}
+          </div>
+        </div>
+        <div
+          v-else
+          class="text-body-2 flex-grow-1"
+        >
+          {{ selectedCells.length }} results selected
+        </div>
+        <v-btn
+          icon
+          small
+          title="Clear the selection"
+          @click="selected = []"
+        >
+          <v-icon small>
+            mdi-close
+          </v-icon>
+        </v-btn>
+      </div>
+      <div class="d-flex align-center mt-1">
+        <v-btn
+          icon
+          small
+          color="success"
+          :title="selectedCell ? 'Mark as a correct match' : 'Mark all as correct matches'"
+          @click="markSelected('positive')"
+        >
+          <v-icon>
+            {{ allMarked('positive') ? 'mdi-check-circle' : 'mdi-check-circle-outline' }}
+          </v-icon>
+        </v-btn>
+        <v-btn
+          icon
+          small
+          color="error"
+          :title="selectedCell ? 'Mark as an incorrect match' : 'Mark all as incorrect matches'"
+          @click="markSelected('negative')"
+        >
+          <v-icon>
+            {{ allMarked('negative') ? 'mdi-close-circle' : 'mdi-close-circle-outline' }}
+          </v-icon>
+        </v-btn>
+        <v-btn
+          v-if="selectedAdopted.length"
+          icon
+          small
+          :title="selectedCell
+            ? 'Delete this annotation' : `Delete ${selectedAdopted.length} annotations`"
+          @click="removeSelected"
+        >
+          <v-icon color="red lighten-1">
+            mdi-delete-outline
+          </v-icon>
+        </v-btn>
+        <v-spacer />
+        <v-btn
+          v-if="selectedCell"
+          small
+          text
+          title="Open in the annotation viewer (or double click)"
+          @click="$emit('open', selectedCell.key)"
+        >
+          <v-icon
+            small
+            left
+          >
+            mdi-open-in-new
+          </v-icon>
+          Open
+        </v-btn>
+      </div>
+      <div
+        v-if="editable"
+        class="d-flex align-center mt-1"
+      >
+        <span class="text-caption grey--text mr-2">Type</span>
+        <ReviewTypeField
+          class="flex-grow-1"
+          :value="selectedType"
+          :options="typeOptions"
+          @commit="assignSelected"
+        />
+      </div>
+    </v-card>
+    <div
+      v-if="loading"
+      class="results-space-status text-caption"
+    >
+      <v-progress-circular
+        indeterminate
+        size="14"
+        width="2"
+        class="mr-2"
+      />
+      Placing results...
+    </div>
+    <div
+      v-else-if="error"
+      class="results-space-status text-caption error--text"
+    >
+      {{ error }}
+    </div>
+    <div
+      v-else-if="!points.length"
+      class="results-space-status text-caption grey--text"
+    >
+      No results to place.
+    </div>
+    <div
+      v-else-if="missingCount"
+      class="results-space-status text-caption grey--text"
+    >
+      {{ missingCount }} result{{ missingCount === 1 ? '' : 's' }} without a stored descriptor left out.
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.results-space {
+  position: relative;
+  width: 100%;
+  height: 100%;
+  min-height: 0;
+  overflow: hidden;
+  user-select: none;
+}
+.results-space-canvas {
+  display: block;
+  width: 100%;
+  height: 100%;
+  cursor: grab;
+}
+.results-space-canvas.results-space-box {
+  cursor: crosshair;
+}
+.results-space-canvas.results-space-hover {
+  cursor: pointer;
+}
+.results-space-tools {
+  position: absolute;
+  top: 6px;
+  right: 6px;
+  display: flex;
+  gap: 2px;
+}
+.results-space-tooltip {
+  position: absolute;
+  pointer-events: none;
+  background: rgba(0, 0, 0, 0.8);
+  border-radius: 3px;
+  padding: 4px 8px;
+  max-width: 220px;
+  white-space: nowrap;
+}
+.results-space-selected {
+  position: absolute;
+  left: 8px;
+  bottom: 8px;
+  width: 300px;
+  background: rgba(18, 18, 18, 0.92);
+}
+.results-space-selected-chip {
+  width: 56px;
+  height: 56px;
+  object-fit: cover;
+  border-radius: 2px;
+}
+.results-space-status {
+  position: absolute;
+  left: 8px;
+  top: 8px;
+  display: flex;
+  align-items: center;
+  pointer-events: none;
+}
+</style>
diff --git a/client/platform/desktop/frontend/querySession.ts b/client/platform/desktop/frontend/querySession.ts
index be7035170..0f07dab6a 100644
--- a/client/platform/desktop/frontend/querySession.ts
+++ b/client/platform/desktop/frontend/querySession.ts
@@ -14,6 +14,10 @@ import type { SearchReview } from './useSearchReview';
 export interface ResultsGridMemory {
   page: number;
   hideReviewed: boolean;
+  /** Showing the 3D descriptor-space view instead of the grid. */
+  space: boolean;
+  /** How many top results the 3D view places. */
+  spaceCount: number;
 }
 
 export interface QuerySession {
diff --git a/client/platform/desktop/frontend/resultSpace.spec.ts b/client/platform/desktop/frontend/resultSpace.spec.ts
new file mode 100644
index 000000000..be1d94fae
--- /dev/null
+++ b/client/platform/desktop/frontend/resultSpace.spec.ts
@@ -0,0 +1,123 @@
+import {
+  billboardHalfSize, DEFAULT_ORBIT, normalizePositions, orbitDrag, orbitPan, orbitZoom,
+  paintOrder, pick, pickInBox, project, rotate,
+} from './resultSpace';
+
+const viewport = { width: 400, height: 300 };
+
+it('normalizes the farthest point onto the unit sphere and keeps the origin fixed', () => {
+  const points = normalizePositions([
+    { key: 'a', position: [0, 0, 0] },
+    { key: 'b', position: [3, 0, 4] },
+    { key: 'c', position: [0, 2.5, 0] },
+  ]);
+  expect(points[0].position).toEqual([0, 0, 0]);
+  expect(points[1].position).toEqual([0.6, 0, 0.8]);
+  expect(points[2].position).toEqual([0, 0.5, 0]);
+  expect(normalizePositions([{ key: 'a', position: [0, 0, 0] }])[0].position).toEqual([0, 0, 0]);
+});
+
+it('projects the origin to the viewport center and nearer points larger', () => {
+  const orbit = { yaw: 0, pitch: 0, zoom: 1 };
+  const [origin, near, far] = project([
+    { key: 'o', position: [0, 0, 0] },
+    { key: 'near', position: [0.5, 0, 0.5] },
+    { key: 'far', position: [0.5, 0, -0.5] },
+  ], orbit, viewport);
+  expect(origin.x).toBe(200);
+  expect(origin.y).toBe(150);
+  expect(origin.scale).toBe(1);
+  expect(near.depth).toBeLessThan(far.depth);
+  expect(near.scale).toBeGreaterThan(1);
+  expect(far.scale).toBeLessThan(1);
+  expect(near.x - 200).toBeGreaterThan(far.x - 200);
+  expect(paintOrder([near, far, origin]).map((p) => p.key)).toEqual(['far', 'o', 'near']);
+});
+
+it('rotates with yaw and pitch and zooms toward the origin', () => {
+  const [x, , z] = rotate([1, 0, 0], { yaw: Math.PI / 2, pitch: 0, zoom: 1 });
+  expect(x).toBeCloseTo(0);
+  expect(z).toBeCloseTo(-1);
+  const [, y, z2] = rotate([0, 0, 1], { yaw: 0, pitch: Math.PI / 2, zoom: 1 });
+  expect(y).toBeCloseTo(-1);
+  expect(z2).toBeCloseTo(0);
+  const [side] = project([{ key: 's', position: [0.5, 0, 0] }], DEFAULT_ORBIT, viewport);
+  const [closer] = project([{ key: 's', position: [0.5, 0, 0] }], orbitZoom(DEFAULT_ORBIT, -100), viewport);
+  expect(Math.abs(closer.x - 200)).toBeGreaterThan(Math.abs(side.x - 200));
+  expect(orbitZoom(DEFAULT_ORBIT, 100000).zoom).toBe(0.4);
+  expect(orbitZoom(DEFAULT_ORBIT, -100000).zoom).toBe(4);
+});
+
+it('clamps the pitch while dragging', () => {
+  const dragged = orbitDrag(DEFAULT_ORBIT, 50, 100000);
+  expect(dragged.yaw).toBeCloseTo(DEFAULT_ORBIT.yaw + 0.4);
+  expect(dragged.pitch).toBeLessThan(Math.PI / 2);
+  expect(orbitDrag(DEFAULT_ORBIT, 0, -100000).pitch).toBeGreaterThan(-Math.PI / 2);
+});
+
+it('picks the nearest billboard under the cursor', () => {
+  const projected = [
+    {
+      key: 'behind', x: 100, y: 100, depth: 4, scale: 0.8,
+    },
+    {
+      key: 'front', x: 104, y: 98, depth: 2, scale: 1.5,
+    },
+    {
+      key: 'elsewhere', x: 300, y: 100, depth: 1, scale: 1,
+    },
+  ];
+  expect(pick(projected, 101, 101, 20)?.key).toBe('front');
+  expect(pick(projected, 100, 100, 1)?.key).toBe('behind');
+  expect(pick(projected, 200, 200, 20)).toBeNull();
+});
+
+it('slides the view with a pan, and the default orbit undoes it', () => {
+  const panned = orbitPan(orbitPan(DEFAULT_ORBIT, 30, -10), 5, 5);
+  expect(panned).toMatchObject({ panX: 35, panY: -5, yaw: DEFAULT_ORBIT.yaw });
+  const [origin] = project([{ key: 'o', position: [0, 0, 0] }], panned, viewport);
+  expect(origin.x).toBe(235);
+  expect(origin.y).toBe(145);
+  const [reset] = project([{ key: 'o', position: [0, 0, 0] }], { ...DEFAULT_ORBIT }, viewport);
+  expect([reset.x, reset.y]).toEqual([200, 150]);
+});
+
+it('picks by each billboard\'s own shape', () => {
+  const projected = [{
+    key: 'thin', x: 100, y: 100, depth: 2, scale: 1,
+  }];
+  const shape = () => [1, 0.25] as [number, number];
+  expect(pick(projected, 115, 100, 20, shape)?.key).toBe('thin');
+  expect(pick(projected, 100, 110, 20, shape)).toBeNull();
+  expect(pick(projected, 100, 110, 20)?.key).toBe('thin');
+});
+
+it('gathers every billboard a drawn box touches, whichever way it was drawn', () => {
+  const projected = [
+    {
+      key: 'a', x: 100, y: 100, depth: 2, scale: 1,
+    },
+    {
+      key: 'b', x: 160, y: 120, depth: 3, scale: 1,
+    },
+    {
+      key: 'c', x: 300, y: 100, depth: 1, scale: 1,
+    },
+  ];
+  const box = {
+    x1: 170, y1: 130, x2: 90, y2: 90,
+  };
+  expect(pickInBox(projected, box, 10)).toEqual(['a', 'b']);
+  // 'c' only touches the box with its edge
+  expect(pickInBox(projected, { ...box, x1: 291 }, 10)).toEqual(['a', 'b', 'c']);
+  expect(pickInBox(projected, {
+    x1: 0, y1: 0, x2: 20, y2: 20,
+  }, 10)).toEqual([]);
+});
+
+it('shrinks billboards once more than a hundred results are shown', () => {
+  expect(billboardHalfSize(25, 26, 8)).toBe(26);
+  expect(billboardHalfSize(100, 26, 8)).toBe(26);
+  expect(billboardHalfSize(250, 26, 8)).toBe(16);
+  expect(billboardHalfSize(1000, 26, 8)).toBe(8);
+});
diff --git a/client/platform/desktop/frontend/resultSpace.ts b/client/platform/desktop/frontend/resultSpace.ts
new file mode 100644
index 000000000..18a0f0b86
--- /dev/null
+++ b/client/platform/desktop/frontend/resultSpace.ts
@@ -0,0 +1,185 @@
+/**
+ * Geometry behind the 3D view of search results: the query sits at the
+ * origin, results float around it at their descriptor-space offsets, and an
+ * orbiting perspective camera projects them onto the canvas.
+ */
+
+export type Vec3 = [number, number, number];
+
+export interface SpacePoint {
+  key: string;
+  position: Vec3;
+}
+
+/**
+ * Camera orbit: yaw about the vertical axis, pitch above the horizon, zoom
+ * factor, and how far the query has been slid from the viewport's center.
+ */
+export interface Orbit {
+  yaw: number;
+  pitch: number;
+  zoom: number;
+  /** Canvas pixels. */
+  panX?: number;
+  panY?: number;
+}
+
+/** A rectangle on the canvas, by two opposite corners in any order. */
+export interface CanvasBox {
+  x1: number;
+  y1: number;
+  x2: number;
+  y2: number;
+}
+
+/** A billboard's half width and half height, as fractions of the square half size. */
+export type Shape = (key: string) => [number, number];
+const SQUARE: Shape = () => [1, 1];
+
+export interface Viewport {
+  width: number;
+  height: number;
+}
+
+/** A point on the canvas, with its depth from the camera and billboard scale. */
+export interface Projected {
+  key: string;
+  x: number;
+  y: number;
+  /** Distance from the camera along its view axis; larger is farther away. */
+  depth: number;
+  /** Size multiplier relative to a billboard at the origin. */
+  scale: number;
+}
+
+export const DEFAULT_ORBIT: Orbit = {
+  yaw: 0.6, pitch: 0.35, zoom: 1, panX: 0, panY: 0,
+};
+
+/** Camera distance from the origin at zoom 1; points are normalized inside radius 1. */
+const CAMERA_DISTANCE = 3.2;
+const MAX_PITCH = Math.PI / 2 - 0.05;
+const MIN_ZOOM = 0.4;
+const MAX_ZOOM = 4;
+const DRAG_RADIANS_PER_PX = 0.008;
+/** Fraction of the shorter viewport side the unit sphere spans at zoom 1. */
+const FIT_FRACTION = 0.38;
+
+/** Scale positions uniformly so the farthest point sits at radius 1. */
+export function normalizePositions(points: SpacePoint[]): SpacePoint[] {
+  const radius = Math.max(...points.map((p) => Math.hypot(...p.position)), 0);
+  if (!(radius > 0)) return points.map((p) => ({ key: p.key, position: [0, 0, 0] }));
+  return points.map((p) => ({
+    key: p.key,
+    position: p.position.map((v) => v / radius) as Vec3,
+  }));
+}
+
+/** Rotate a point into camera-aligned coordinates (camera looks down -z). */
+export function rotate([x, y, z]: Vec3, orbit: Orbit): Vec3 {
+  const cy = Math.cos(orbit.yaw);
+  const sy = Math.sin(orbit.yaw);
+  const x1 = cy * x + sy * z;
+  const z1 = -sy * x + cy * z;
+  const cp = Math.cos(orbit.pitch);
+  const sp = Math.sin(orbit.pitch);
+  const y2 = cp * y - sp * z1;
+  const z2 = sp * y + cp * z1;
+  return [x1, y2, z2];
+}
+
+export function cameraDistance(orbit: Orbit): number {
+  return CAMERA_DISTANCE / orbit.zoom;
+}
+
+/**
+ * Perspective projection of every point; the origin projects to the
+ * viewport center, moved by the orbit's pan.
+ */
+export function project(points: SpacePoint[], orbit: Orbit, viewport: Viewport): Projected[] {
+  const distance = cameraDistance(orbit);
+  const focal = FIT_FRACTION * Math.min(viewport.width, viewport.height) * CAMERA_DISTANCE;
+  const cx = viewport.width / 2 + (orbit.panX ?? 0);
+  const cy = viewport.height / 2 + (orbit.panY ?? 0);
+  return points.map((point) => {
+    const [x, y, z] = rotate(point.position, orbit);
+    const depth = distance - z;
+    const s = focal / depth;
+    return {
+      key: point.key,
+      x: cx + x * s,
+      y: cy - y * s,
+      depth,
+      scale: distance / depth,
+    };
+  });
+}
+
+/** Far to near, so nearer billboards paint over farther ones. */
+export function paintOrder(projected: Projected[]): Projected[] {
+  return [...projected].sort((a, b) => b.depth - a.depth);
+}
+
+/**
+ * The nearest billboard under a canvas position, given the billboards' half
+ * size at scale 1. They are centered on their point, square unless `shape`
+ * says otherwise.
+ */
+export function pick(
+  projected: Projected[],
+  x: number,
+  y: number,
+  halfSize: number,
+  shape: Shape = SQUARE,
+): Projected | null {
+  let best: Projected | null = null;
+  projected.forEach((p) => {
+    const [wide, tall] = shape(p.key);
+    const half = halfSize * p.scale;
+    if (Math.abs(p.x - x) > half * wide || Math.abs(p.y - y) > half * tall) return;
+    if (!best || p.depth < best.depth) best = p;
+  });
+  return best;
+}
+
+/** Every billboard a box drawn on the canvas touches. */
+export function pickInBox(
+  projected: Projected[],
+  box: CanvasBox,
+  halfSize: number,
+  shape: Shape = SQUARE,
+): string[] {
+  const [left, right] = [Math.min(box.x1, box.x2), Math.max(box.x1, box.x2)];
+  const [top, bottom] = [Math.min(box.y1, box.y2), Math.max(box.y1, box.y2)];
+  return projected.filter((p) => {
+    const [wide, tall] = shape(p.key);
+    const half = halfSize * p.scale;
+    return p.x + half * wide >= left && p.x - half * wide <= right
+      && p.y + half * tall >= top && p.y - half * tall <= bottom;
+  }).map((p) => p.key);
+}
+
+/** Billboards shrink as more results are shown, so a thousand still read as separate. */
+export function billboardHalfSize(count: number, halfSize: number, smallest: number): number {
+  const crowding = count > 100 ? Math.sqrt(100 / count) : 1;
+  return Math.max(smallest, Math.round(halfSize * crowding));
+}
+
+export function orbitDrag(orbit: Orbit, dx: number, dy: number): Orbit {
+  return {
+    ...orbit,
+    yaw: orbit.yaw + dx * DRAG_RADIANS_PER_PX,
+    pitch: Math.max(-MAX_PITCH, Math.min(MAX_PITCH, orbit.pitch + dy * DRAG_RADIANS_PER_PX)),
+  };
+}
+
+/** Slide the whole view across the canvas. */
+export function orbitPan(orbit: Orbit, dx: number, dy: number): Orbit {
+  return { ...orbit, panX: (orbit.panX ?? 0) + dx, panY: (orbit.panY ?? 0) + dy };
+}
+
+/** Wheel zoom: each 100 units of deltaY scales by ~1.25x. */
+export function orbitZoom(orbit: Orbit, deltaY: number): Orbit {
+  const zoom = orbit.zoom * (1.25 ** (-deltaY / 100));
+  return { ...orbit, zoom: Math.max(MIN_ZOOM, Math.min(MAX_ZOOM, zoom)) };
+}
diff --git a/client/platform/desktop/frontend/useSearchChips.ts b/client/platform/desktop/frontend/useSearchChips.ts
index 85400e59a..83683e387 100644
--- a/client/platform/desktop/frontend/useSearchChips.ts
+++ b/client/platform/desktop/frontend/useSearchChips.ts
@@ -60,6 +60,11 @@ function createScopedSearchChips(search: VideoSearchContextType, options: Search
     padding: DEFAULT_REVIEW_GRID.padding, size: PanelChipSize, aspect: 1, outline: '#00e5ff',
   });
 
+  // The 3D results view shows each result as its box alone, with no context
+  const tightStore = createChipStore({ frameSourceFor: registry.frameSourceFor }, {
+    padding: 0, size: PanelChipSize, aspect: 1, outline: '', tight: true,
+  });
+
   /** Every current result as a grid item, in rank order. */
   const items = computed<ReviewItem[]>(() => (options.results?.value ?? search.state.results)
     .filter((result) => !options.hidden?.(result))
@@ -84,6 +89,7 @@ function createScopedSearchChips(search: VideoSearchContextType, options: Search
       // New query: refs may repeat with different content, so start over.
       generation = search.state.queryGeneration;
       store.reset();
+      tightStore.reset();
     }
     // Refinement re-ranks within the same query; cached chips stay valid.
     store.ensurePrimary(current.slice(0, EagerLoadCount));
@@ -91,14 +97,17 @@ function createScopedSearchChips(search: VideoSearchContextType, options: Search
 
   function dispose() {
     store.reset();
+    tightStore.reset();
     registry.dispose();
   }
 
   return {
     store,
+    tightStore,
     items,
     itemsByRef,
     chips: store.chips,
+    tightChips: tightStore.chips,
     dispose,
   };
 }
diff --git a/client/platform/desktop/frontend/useVideoSearch.ts b/client/platform/desktop/frontend/useVideoSearch.ts
index e5d4d2da3..b976941aa 100644
--- a/client/platform/desktop/frontend/useVideoSearch.ts
+++ b/client/platform/desktop/frontend/useVideoSearch.ts
@@ -11,12 +11,12 @@
 import { reactive, provide, inject } from 'vue';
 import type {
   VideoSearchIndexStatus, VideoSearchIndexMethod, VideoSearchIndexInfo,
-  VideoSearchResult, VideoSearchQueryResponse,
+  VideoSearchResult, VideoSearchQueryResponse, VideoSearchLayoutResponse,
 } from 'dive-common/apispec';
 import {
   videoSearchInstalled, videoSearchIndexStatus, videoSearchBuildIndex,
   videoSearchRemoveIndex, videoSearchOpenIndex,
-  videoSearchFormulate, videoSearchQuery, videoSearchRefine,
+  videoSearchFormulate, videoSearchQuery, videoSearchRefine, videoSearchLayout,
   videoSearchExportModel, videoSearchClose, videoSearchExtractFrame,
   loadConfig,
 } from 'platform/desktop/frontend/api';
@@ -317,6 +317,15 @@ export function createVideoSearch(
     });
   }
 
+  /**
+   * Positions of the given results in descriptor space around the query.
+   * Read-only on the service, so it neither takes nor waits for the busy
+   * flag (the service answers requests in order anyway).
+   */
+  async function layoutResults(refs: string[]): Promise<VideoSearchLayoutResponse> {
+    return videoSearchLayout(refs);
+  }
+
   async function saveModel(name: string): Promise<string | undefined> {
     return guarded('Saving model...', async () => {
       const { outputDir } = await videoSearchExportModel(name);
@@ -354,6 +363,7 @@ export function createVideoSearch(
     resultDatasetName,
     mark,
     refine,
+    layoutResults,
     saveModel,
     closeSession,
   };
diff --git a/docs/Query.md b/docs/Query.md
index 0cdc125a3..091c3ec8d 100644
--- a/docs/Query.md
+++ b/docs/Query.md
@@ -29,6 +29,8 @@ Results can be turned into annotations without leaving the page: accepted result
 
 **Text.** Type what to find. Sampled frames of every listed dataset (every N frames, up to a per-dataset cap) are searched with the SAM3 text model, which must be installed as a VIAME add-on. Hits show in the grid with their label and score. Each hit offers **Search the index for objects like this one**, which turns it into an image query, and **Open in the annotation viewer**.
 
+The results toolbar can switch from the grid to a **3D view** (the cube button; off by default) that places the top results around the query in descriptor space: the query exemplar sits at the center, each result hangs off it on a line, and results with similar descriptors cluster together, with the more similar ones closer to the center. Positions are the results' descriptor offsets from the query projected onto the three principal axes of the shown set. Choose how many top results to place (up to 1000; this needs a VIAME whose query service returns that many), drag to orbit, drag with the middle button to slide the view, use the wheel to zoom, and press the reset button to bring the query back to the center. Results are shown cropped to their box alone. Click a result to mark it correct or incorrect, and double click to open it. To work on several at once, hold shift and drag a box over them (or turn on the box tool), then mark them all correct or incorrect, give them all a type, or delete them together; shift click adds or removes a single result.
+
 Double clicking any result opens its dataset in the viewer at that frame. Coming back to Query afterwards resumes the page as it was left: the exemplar, the results and their marks, unsaved annotation edits, and the grid page, so adjudication carries on where it stopped.
 
 Index builds appear in **Jobs** while preparing and running, with their dataset, indexing method, live stdout/stderr, and final result. Expand the job's output to diagnose failures; the process log is also saved as `runlog.txt` in its working directory. Builds waiting for the GPU appear under **Queued Jobs** as indexing jobs. Startup failures remain in job history.
diff --git a/server/dive_tasks/run_training.py b/server/dive_tasks/run_training.py
index 8f3e3ce09..3c039aaf0 100644
--- a/server/dive_tasks/run_training.py
+++ b/server/dive_tasks/run_training.py
@@ -12,7 +12,7 @@
 from dive_tasks import utils
 from dive_tasks.manager import patch_manager
 from dive_tasks.viame_config import Config
-from dive_utils import constants
+from dive_utils import constants, model_pack
 from dive_utils.types import ExportTrainedPipelineJob, TrainingJob
 
 
@@ -188,6 +188,17 @@ def train_pipeline(self: Task, params: TrainingJob):
         }
         utils.stream_subprocess(self, context, manager, popen_kwargs)
 
+        # Current VIAME packs the whole output into one zip; older releases and
+        # SVM trainers leave a folder (category_models before the rename)
+        pack_path = output_path / "trained_model.zip"
+        if pack_path.exists():
+            training_results_path = utils.make_directory(output_path / "trained_model")
+            model_pack.extract_model_pack(pack_path, training_results_path)
+        elif len(list(training_results_path.glob("*"))) == 0:
+            legacy_path = output_path / "category_models"
+            if legacy_path.exists() and any(legacy_path.iterdir()):
+                training_results_path = legacy_path
+
         # Check that there are results in the output path
         if len(list(training_results_path.glob("*"))) == 0:
             raise RuntimeError("Training output didn't produce results, discarding...")