diff --git a/desktop/src/electron/model-hub/index.ts b/desktop/src/electron/model-hub/index.ts
index d1fda727..ef6882e0 100644
--- a/desktop/src/electron/model-hub/index.ts
+++ b/desktop/src/electron/model-hub/index.ts
@@ -2,8 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { EngineType } from '@/shared/types/engines'
-import type { EngineHubModel, EngineHubSearchResponse } from '@/shared/types/engine-api'
+import type {
+    EngineHubLookupResponse,
+    EngineHubModel,
+    EngineHubSearchResponse
+} from '@/shared/types/engine-api'
 import { loadOllamaModels, type OllamaTagsModel } from '@/electron/model-hub/ollama-library'
+import { lookupOllamaModel } from '@/electron/model-hub/ollama-registry'
 import {
     lmStudioCatalogCache,
     type LmStudioCatalogModel
@@ -15,11 +20,16 @@ function ollamaToHubModel(m: OllamaTagsModel): EngineHubModel {
         id: m.name,
         name: m.name,
         author: '',
-        url: `https://ollama.com/library/${base}`,
+        // A namespaced name addresses that namespace's page; a bare one is a
+        // first-party model under `library`.
+        url: base.includes('/')
+            ? `https://ollama.com/${base}`
+            : `https://ollama.com/library/${base}`,
         size: m.size > 0 ? m.size : undefined,
         downloads: 0,
         likes: 0,
-        updatedAt: m.modified_at || new Date().toISOString(),
+        // Empty means the source reported no date; the row omits its age.
+        updatedAt: m.modified_at,
         tags: [],
         family: m.details.family || undefined,
         parameterSize: m.details.parameter_size || undefined
@@ -57,6 +67,30 @@ export async function getEngineHubModels(engineType: EngineType): Promise<Engine
     }
 }
 
+/**
+ * Resolve one exact model name {@link getEngineHubModels} did not return.
+ * Ollama's list is a committed snapshot, so a model published since it was taken
+ * is absent from the browse list even though the engine can pull it; this asks
+ * Ollama's registry for that one name.
+ *
+ * A null model means "not available" for every cause alike — no lookup source
+ * for the engine, no such model, or an unreachable registry. LM Studio has none
+ * because its catalog is fetched live and never falls behind a release.
+ */
+export async function lookupEngineHubModel(
+    engineType: EngineType,
+    name: string
+): Promise<EngineHubLookupResponse> {
+    switch (engineType) {
+        case 'ollama': {
+            const found = await lookupOllamaModel(name)
+            return { model: found ? ollamaToHubModel(found) : null }
+        }
+        default:
+            return { model: null }
+    }
+}
+
 /**
  * Kick a background refresh of the live engine hub caches so the first modal
  * open is instant. Ollama needs no warming (it is a committed static list);
diff --git a/desktop/src/electron/model-hub/ollama-registry.ts b/desktop/src/electron/model-hub/ollama-registry.ts
new file mode 100644
index 00000000..62b49551
--- /dev/null
+++ b/desktop/src/electron/model-hub/ollama-registry.ts
@@ -0,0 +1,239 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import axios, { isAxiosError } from 'axios'
+import { createStructuredLogger } from '@/shared/utils/log'
+import getErrorString from '@/shared/utils/get-error-string'
+import type { OllamaTagsModel } from '@/electron/model-hub/ollama-library'
+
+const log = createStructuredLogger('ollama-registry')
+
+/**
+ * Resolve one Ollama model by exact name, for names the committed catalog
+ * snapshot (`ollama-models.json`) does not carry.
+ *
+ * `registry.ollama.ai` speaks the OCI distribution API that `ollama pull` uses,
+ * so this asks the same source the engine would. It only reads manifests: the
+ * registry answers 404 for `/tags/list`, so enumerating a catalog still needs
+ * the snapshot and a lookup is an exact-name check rather than a search.
+ */
+
+const REGISTRY_BASE = 'https://registry.ollama.ai/v2'
+const USER_AGENT = 'PAIR/1.0'
+
+/**
+ * Bounds the whole request rather than just the response. `axios`'s `timeout` is
+ * a socket timeout and does not start until a socket exists, so it misses a
+ * wedged DNS resolver; an `AbortSignal` covers every phase. `lmstudio-catalog.ts`
+ * carries the same reasoning at more length.
+ */
+const HTTP_TIMEOUT_MS = 8_000
+
+/** What `ollama pull <name>` resolves a bare name to. */
+const DEFAULT_TAG = 'latest'
+
+/** Ollama's namespace for first-party models, implied by a bare name. */
+const DEFAULT_NAMESPACE = 'library'
+
+/**
+ * Characters a repository segment or tag may contain. This is the only guard on
+ * what reaches the request URL, so it has to hold on its own: the renderer runs
+ * its own check before asking, but a lookup arrives over IPC and main-process
+ * code does not treat the renderer as trusted. Without it, `foo/..` walks out of
+ * the namespace and `foo/bar#z` truncates the path.
+ */
+const SAFE_SEGMENT = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/
+
+/**
+ * Positive and negative results both cached, because the hub looks names up as
+ * the user types and would otherwise re-request on every keystroke past a
+ * resolved name. Bounded so a long session cannot grow it without limit.
+ */
+const CACHE_LIMIT = 256
+const cache = new Map<string, OllamaTagsModel | null>()
+
+function remember(key: string, value: OllamaTagsModel | null): OllamaTagsModel | null {
+    if (cache.size >= CACHE_LIMIT) {
+        // Map iteration is insertion-ordered, so the first key is the oldest.
+        const oldest = cache.keys().next()
+        if (!oldest.done) cache.delete(oldest.value)
+    }
+    cache.set(key, value)
+    return value
+}
+
+/**
+ * Split `[namespace/]name[:tag]` into a registry path and tag, or null for a
+ * reference this registry cannot answer.
+ *
+ * OCI clients read a dot in the first of *several* segments as a registry
+ * hostname, which is how `hf.co/<user>/<repo>` is recognized as someone else's
+ * registry and declined rather than reported as missing. That rule must not
+ * reach a lone segment: bare model names legitimately carry dots — `qwen3.8`,
+ * `llama3.1`, `phi3.5` — and are always first-party names under `library`.
+ */
+function parseReference(name: string): { path: string; tag: string } | null {
+    const colon = name.lastIndexOf(':')
+    const slash = name.lastIndexOf('/')
+    // A colon ahead of the last slash belongs to a host:port, not a tag.
+    const hasTag = colon > slash
+    const repository = hasTag ? name.slice(0, colon) : name
+    const tag = hasTag ? name.slice(colon + 1) : DEFAULT_TAG
+    if (!SAFE_SEGMENT.test(tag)) return null
+
+    const segments = repository.split('/')
+    if (!segments.every(segment => SAFE_SEGMENT.test(segment))) return null
+    if (segments.length === 1) return { path: `${DEFAULT_NAMESPACE}/${segments[0]}`, tag }
+    if (segments.length > 2 || segments[0].includes('.')) return null
+    return { path: repository, tag }
+}
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+    return v !== null && typeof v === 'object'
+}
+
+function manifestLayers(raw: unknown): Record<string, unknown>[] {
+    if (!isRecord(raw) || !Array.isArray(raw.layers)) return []
+    return raw.layers.filter(isRecord)
+}
+
+/**
+ * Total bytes the engine downloads: every layer, not just the weights. The
+ * others (template, params, license) are a few kilobytes each, but the sum is
+ * what lands on disk.
+ */
+function totalLayerBytes(raw: unknown): number {
+    let total = 0
+    for (const layer of manifestLayers(raw)) {
+        if (typeof layer.size === 'number' && layer.size > 0) total += layer.size
+    }
+    return total
+}
+
+/**
+ * Capability chip for the row. `details.family` carries a capability rather than
+ * a model family here, because that is what the catalog scraper puts there and
+ * what the row renders.
+ *
+ * Vision is the only one a manifest proves: a multimodal model carries an extra
+ * `projector` layer for its vision encoder and nothing else does. Tools,
+ * thinking and embedding exist only on ollama.com's rendered page, so a model
+ * with those and no projector gets no chip instead of a wrong one.
+ */
+function capabilityFromLayers(raw: unknown): string {
+    const vision = manifestLayers(raw).some(
+        layer => layer.mediaType === 'application/vnd.ollama.image.projector'
+    )
+    return vision ? 'vision' : ''
+}
+
+function configDigest(raw: unknown): string {
+    if (!isRecord(raw) || !isRecord(raw.config)) return ''
+    return typeof raw.config.digest === 'string' ? raw.config.digest : ''
+}
+
+/** The 12-character form Ollama shows in its own model lists. */
+function shortenDigest(digest: string): string {
+    return digest.replace(/^sha256:/, '').slice(0, 12)
+}
+
+/**
+ * What the model says about itself, read from the config blob the manifest
+ * points at. Worth the extra request because a tag like `27b-coding-mxfp8` is a
+ * label the publisher chose, while these are the real figures.
+ */
+interface OllamaModelConfig {
+    format: string
+    families: string[] | null
+    parameterSize: string
+    quantizationLevel: string
+}
+
+/** Resolves to null on any failure; the row still renders, with less on it. */
+async function fetchConfig(path: string, digest: string): Promise<OllamaModelConfig | null> {
+    if (!digest) return null
+    try {
+        const { data } = await axios.get<unknown>(`${REGISTRY_BASE}/${path}/blobs/${digest}`, {
+            headers: { 'User-Agent': USER_AGENT, Accept: 'application/json' },
+            signal: AbortSignal.timeout(HTTP_TIMEOUT_MS)
+        })
+        if (!isRecord(data)) return null
+        const families = Array.isArray(data.model_families)
+            ? data.model_families.filter((f): f is string => typeof f === 'string')
+            : []
+        return {
+            format: typeof data.model_format === 'string' ? data.model_format : '',
+            families: families.length > 0 ? families : null,
+            parameterSize: typeof data.model_type === 'string' ? data.model_type : '',
+            quantizationLevel: typeof data.file_type === 'string' ? data.file_type : ''
+        }
+    } catch {
+        return null
+    }
+}
+
+/**
+ * Look one exact model name up in Ollama's registry.
+ *
+ * Null covers every "not available" case alike — a reference this registry does
+ * not serve, a model or tag that does not exist, a timeout, an offline machine.
+ * None of them surface as an error: the lookup is speculative, and the user
+ * asked to search rather than to make this request.
+ */
+export async function lookupOllamaModel(name: string): Promise<OllamaTagsModel | null> {
+    const cached = cache.get(name)
+    if (cached !== undefined) return cached
+
+    const reference = parseReference(name)
+    if (!reference) return remember(name, null)
+
+    try {
+        const { data } = await axios.get<unknown>(
+            `${REGISTRY_BASE}/${reference.path}/manifests/${reference.tag}`,
+            {
+                headers: {
+                    'User-Agent': USER_AGENT,
+                    Accept: 'application/vnd.docker.distribution.manifest.v2+json'
+                },
+                signal: AbortSignal.timeout(HTTP_TIMEOUT_MS)
+            }
+        )
+        const size = totalLayerBytes(data)
+        if (size === 0) return remember(name, null)
+
+        const digest = configDigest(data)
+        const config = await fetchConfig(reference.path, digest)
+
+        log.info({ sublevel: 'lookup', message: `resolved ${name} outside the catalog snapshot` })
+        return remember(name, {
+            name,
+            model: name,
+            // Neither the manifest nor its headers carry a publication date.
+            // Empty means unknown, and the row omits its age rather than
+            // claiming the model was updated just now.
+            modified_at: '',
+            size,
+            digest: shortenDigest(digest),
+            details: {
+                parent_model: '',
+                format: config?.format ?? '',
+                family: capabilityFromLayers(data),
+                families: config?.families ?? null,
+                // Falls back to the tag, which is what the catalog shows here.
+                parameter_size:
+                    config?.parameterSize || (reference.tag === DEFAULT_TAG ? '' : reference.tag),
+                quantization_level: config?.quantizationLevel ?? ''
+            }
+        })
+    } catch (err) {
+        const status = isAxiosError(err) ? err.response?.status : undefined
+        // 404 is the ordinary answer for a name that does not exist.
+        if (status !== 404) {
+            log.warn({
+                sublevel: 'http',
+                message: `lookup for ${name} failed: ${status ?? ''} ${getErrorString(err)}`.trim()
+            })
+        }
+        return remember(name, null)
+    }
+}
diff --git a/desktop/src/electron/service-bridge/empty-handlers.ts b/desktop/src/electron/service-bridge/empty-handlers.ts
index dc5c2dd8..b7143790 100644
--- a/desktop/src/electron/service-bridge/empty-handlers.ts
+++ b/desktop/src/electron/service-bridge/empty-handlers.ts
@@ -11,7 +11,7 @@ import {
     MODULAR_ENGINE_LIFECYCLE_CALL_TIMEOUT_MS
 } from '@/shared/constants/modular-runtime'
 import getErrorString from '@/shared/utils/get-error-string'
-import { getEngineHubModels } from '@/electron/model-hub'
+import { getEngineHubModels, lookupEngineHubModel } from '@/electron/model-hub'
 import { getModularSupervisor } from './modular-supervisor'
 import {
     getModularBridgeState,
@@ -966,6 +966,8 @@ const EMPTY_SERVICE_BRIDGE_HANDLERS: BridgeHandlerMap = {
     'engine:command': payload => handleEngineCommand(payload),
     'engine:search-hub': payload =>
         payload ? getEngineHubModels(payload.engineType) : { models: [] },
+    'engine:lookup-hub-model': payload =>
+        payload ? lookupEngineHubModel(payload.engineType, payload.name) : { model: null },
 
     'errors:get-initial': () => handleErrorsGetInitial(),
     'errors:clear': payload => (payload ? handleErrorsClear(payload) : null),
diff --git a/desktop/src/shared/types/engine-api.ts b/desktop/src/shared/types/engine-api.ts
index 351f5c5b..208caf2a 100644
--- a/desktop/src/shared/types/engine-api.ts
+++ b/desktop/src/shared/types/engine-api.ts
@@ -37,6 +37,15 @@ export interface EngineHubSearchResponse {
     models: EngineHubModel[]
 }
 
+/**
+ * Response for the `engine:lookup-hub-model` channel. `null` means the name is
+ * not available, whether because it does not exist, the engine has no registry
+ * to ask, or that registry could not be reached.
+ */
+export interface EngineHubLookupResponse {
+    model: EngineHubModel | null
+}
+
 /** Engine command discriminator. */
 export type EngineCommandType =
     | 'toggle'
diff --git a/desktop/src/shared/types/ws-channels.ts b/desktop/src/shared/types/ws-channels.ts
index 07398eab..29647b81 100644
--- a/desktop/src/shared/types/ws-channels.ts
+++ b/desktop/src/shared/types/ws-channels.ts
@@ -25,6 +25,7 @@
  */
 import type {
     EngineCommandPayload,
+    EngineHubLookupResponse,
     EngineHubSearchResponse,
     EngineInitialState,
     EngineStatePatch
@@ -93,6 +94,12 @@ export interface WsInvokeChannelMap {
     'engines:get-initial': { request: void; response: EngineInitialState }
     'engine:command': { request: EngineCommandPayload; response: null }
     'engine:search-hub': { request: { engineType: EngineType }; response: EngineHubSearchResponse }
+    // Exact-name lookup, used only when a search matches nothing, so the
+    // catalog the app ships with cannot hide a model the engine could pull.
+    'engine:lookup-hub-model': {
+        request: { engineType: EngineType; name: string }
+        response: EngineHubLookupResponse
+    }
 
     // Errors
     'errors:get-initial': { request: void; response: ServiceError[] }
diff --git a/desktop/src/ui/api/engine-api.ts b/desktop/src/ui/api/engine-api.ts
index 69fd71a2..e691ba98 100644
--- a/desktop/src/ui/api/engine-api.ts
+++ b/desktop/src/ui/api/engine-api.ts
@@ -9,6 +9,7 @@
  */
 import type { PreloadServiceTransport as ServiceTransport } from '@/shared/types/service-bridge'
 import type {
+    EngineHubLookupResponse,
     EngineHubSearchResponse,
     EngineInitialState,
     EngineStatePatch,
@@ -49,6 +50,8 @@ export interface IEngineApi {
     setModelExpiry(engineType: EngineType, nodeId: string, model: string, expiry: string): void
     /** Search the model registry/hub for available models. */
     searchHub(engineType: EngineType): Promise<EngineHubSearchResponse>
+    /** Resolve one exact model name the hub catalog does not list. */
+    lookupHubModel(engineType: EngineType, name: string): Promise<EngineHubLookupResponse>
 
     /** Durable engine state changed. Prefer this for new renderer state. */
     onStateChanged(callback: (patch: EngineStatePatch) => void): () => void
@@ -103,6 +106,8 @@ export function createEngineApi(transport: ServiceTransport): IEngineApi {
                 expiry
             }),
         searchHub: engineType => transport.invoke('engine:search-hub', { engineType }),
+        lookupHubModel: (engineType, name) =>
+            transport.invoke('engine:lookup-hub-model', { engineType, name }),
 
         onStateChanged: cb => transport.subscribePush('engines:state-changed', cb),
         onProgress: cb => transport.subscribePush('engines:progress-changed', cb),
diff --git a/desktop/src/ui/components/ModelHub/EngineHubListRow.tsx b/desktop/src/ui/components/ModelHub/EngineHubListRow.tsx
index 10c0ccdb..17bba043 100644
--- a/desktop/src/ui/components/ModelHub/EngineHubListRow.tsx
+++ b/desktop/src/ui/components/ModelHub/EngineHubListRow.tsx
@@ -75,12 +75,14 @@ const EngineHubListRow = memo(function EngineHubListRow({
                             </Text>
                         )}
 
-                        <Text
-                            kind="body/regular/sm"
-                            className="text-subtle-color whitespace-nowrap"
-                        >
-                            Updated {formatRelativeTime(new Date(model.updatedAt).getTime())}
-                        </Text>
+                        {!!model.updatedAt && (
+                            <Text
+                                kind="body/regular/sm"
+                                className="text-subtle-color whitespace-nowrap"
+                            >
+                                Updated {formatRelativeTime(model.updatedAt.getTime())}
+                            </Text>
+                        )}
 
                         {!!model.url && (
                             <Button
diff --git a/desktop/src/ui/components/ModelHub/ModelHubContent.tsx b/desktop/src/ui/components/ModelHub/ModelHubContent.tsx
index 061b25f6..ed6f7d64 100644
--- a/desktop/src/ui/components/ModelHub/ModelHubContent.tsx
+++ b/desktop/src/ui/components/ModelHub/ModelHubContent.tsx
@@ -8,9 +8,10 @@ import { ModelHubActions } from './ModelHubActions'
 import { InlineErrorBanner } from '@/ui/components/InlineErrorBanner'
 import { ModelEntry, SortState } from '@/ui/types/model-hub'
 import { ModelHubList } from './ModelHubList'
-import { searchEngineHub } from '@/ui/utils/model-hub-search'
+import { lookupEngineHubModel, searchEngineHub } from '@/ui/utils/model-hub-search'
 import { resolveStoredSort, writeStoredSort } from '@/ui/utils/model-hub-content-storage'
 import { isHubEntryDownloaded } from '@/ui/utils/match-downloaded-model'
+import { resolveLookupQuery } from '@/ui/utils/model-hub-lookup'
 import { EngineType } from '@/shared/types/engines'
 import type { ModelItem } from '@/ui/types/engine-info'
 import getErrorString from '@/shared/utils/get-error-string'
@@ -23,6 +24,12 @@ type ModelHubContentProps = {
     downloadedModels?: readonly ModelItem[]
 }
 
+/** Stable empty list so the lookup memo does not churn every render. */
+const NO_DOWNLOADED_MODELS: readonly ModelItem[] = []
+
+/** How long typing has to settle before an unlisted name is looked up. */
+const LOOKUP_DEBOUNCE_MS = 400
+
 const SORT_DEFAULT_STATE: SortState = {
     sort: 'lastModified',
     sortDescending: false,
@@ -48,6 +55,9 @@ export const ModelHubContent = ({
         engine ? resolveStoredSort(engine, SORT_DEFAULT_STATE) : { ...SORT_DEFAULT_STATE }
     )
     const [errors, setErrors] = useState<{ id: string; message: string }[]>([])
+    // At most one, since a lookup resolves an exact name rather than searching.
+    const [lookupResult, setLookupResult] = useState<ModelEntry | null>(null)
+    const [lookingUp, setLookingUp] = useState(false)
 
     // Per-engine raw-response cache so reopening an engine is instant and
     // keystrokes filter locally instead of re-invoking the search IPC.
@@ -55,6 +65,8 @@ export const ModelHubContent = ({
     // Monotonic generation guard so a stale in-flight fetch never overwrites
     // results for the engine the user has since switched to.
     const fetchGenRef = useRef(0)
+    // The same guard for lookups, which race each other as the query changes.
+    const lookupGenRef = useRef(0)
 
     const loadModels = useCallback(async (backend: EngineType) => {
         const cached = cacheRef.current.get(backend)
@@ -111,6 +123,51 @@ export const ModelHubContent = ({
         return queryFiltered.filter(m => !isHubEntryDownloaded(engine, m, downloadedModels))
     }, [engine, queryFiltered, downloadedModels])
 
+    // A query that matches nothing locally may still name a real model, because
+    // the catalog is a snapshot. Resolve the exact name against the engine's
+    // registry and fold the answer in as an ordinary row.
+    //
+    // Runs only once the local list is known to be empty, and debounced, so
+    // filtering stays instant and a query the snapshot already answers never
+    // leaves the renderer.
+    useEffect(() => {
+        setLookupResult(null)
+        const name = loading || visibleModels.length > 0 ? null : resolveLookupQuery(engine, query)
+        if (!engine || !name) {
+            setLookingUp(false)
+            return
+        }
+
+        const generation = ++lookupGenRef.current
+        setLookingUp(true)
+        const timer = setTimeout(() => {
+            void lookupEngineHubModel(engine, name).then(found => {
+                if (lookupGenRef.current !== generation) return
+                setLookupResult(found)
+                setLookingUp(false)
+            })
+        }, LOOKUP_DEBOUNCE_MS)
+
+        return () => {
+            clearTimeout(timer)
+            // Supersede a request still in flight for the previous query.
+            lookupGenRef.current += 1
+        }
+    }, [engine, query, loading, visibleModels.length])
+
+    // A resolved model that is already installed stays hidden: the hub filters
+    // downloaded models out, which is what emptied the list and prompted the
+    // lookup to begin with.
+    const displayModels = useMemo(() => {
+        if (!engine || !lookupResult) return visibleModels
+        const installed = isHubEntryDownloaded(
+            engine,
+            lookupResult,
+            downloadedModels ?? NO_DOWNLOADED_MODELS
+        )
+        return installed ? visibleModels : [...visibleModels, lookupResult]
+    }, [visibleModels, lookupResult, engine, downloadedModels])
+
     const handleSortPersist = useCallback(
         (next: SortState) => {
             setSort(next)
@@ -121,8 +178,9 @@ export const ModelHubContent = ({
         [engine]
     )
 
-    const modelsRef = useRef(allModels)
-    modelsRef.current = allModels
+    // Covers the looked-up row too, so selecting it resolves like any other.
+    const modelsRef = useRef(displayModels)
+    modelsRef.current = displayModels
 
     const handleSubmit = useCallback(
         (ids: string[]) => {
@@ -192,8 +250,8 @@ export const ModelHubContent = ({
                     className="grow min-h-0"
                     disabled={disabledListClick}
                     multiple={multiple}
-                    loading={loading}
-                    models={visibleModels}
+                    loading={loading || (lookingUp && displayModels.length === 0)}
+                    models={displayModels}
                     selectedModels={selectedModels}
                     onToggleSelectModel={handleListToggle}
                     sort={sort}
diff --git a/desktop/src/ui/components/ModelHub/ModelHubList.tsx b/desktop/src/ui/components/ModelHub/ModelHubList.tsx
index b8e23048..5581486c 100644
--- a/desktop/src/ui/components/ModelHub/ModelHubList.tsx
+++ b/desktop/src/ui/components/ModelHub/ModelHubList.tsx
@@ -84,9 +84,10 @@ export const ModelHubList = ({
 
         switch (sort.sort) {
             case 'lastModified': {
-                const lastModifiedSort = copy.sort(
-                    (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
-                )
+                // A row with no known date sorts oldest, rather than NaN-ing the
+                // comparator and leaving the whole order undefined.
+                const when = (m: ModelEntry): number => m.updatedAt?.getTime() ?? 0
+                const lastModifiedSort = copy.sort((a, b) => when(b) - when(a))
                 return sort.sortDescending ? lastModifiedSort.reverse() : lastModifiedSort
             }
             case 'name': {
diff --git a/desktop/src/ui/types/model-hub.ts b/desktop/src/ui/types/model-hub.ts
index 668e57a7..df792f76 100644
--- a/desktop/src/ui/types/model-hub.ts
+++ b/desktop/src/ui/types/model-hub.ts
@@ -14,7 +14,12 @@ export interface ModelEntry {
     author: string
     url: string
     size?: number
-    updatedAt: Date
+    /**
+     * Publication date, when the source reports one. Undefined for a model
+     * resolved by exact-name lookup, since an OCI manifest carries no date and
+     * the current time would give the row an age it never had.
+     */
+    updatedAt?: Date
     family?: string
     parameterSize?: string
 }
diff --git a/desktop/src/ui/utils/model-hub-lookup.ts b/desktop/src/ui/utils/model-hub-lookup.ts
new file mode 100644
index 00000000..a52aec12
--- /dev/null
+++ b/desktop/src/ui/utils/model-hub-lookup.ts
@@ -0,0 +1,68 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { EngineType } from '@/shared/types/engines'
+
+/**
+ * Decides whether a search that matched nothing is worth resolving against the
+ * engine's registry.
+ *
+ * The Ollama hub browses a committed snapshot, so a model published after that
+ * snapshot was taken is missing from the list even though the engine can pull
+ * it; `engine:lookup-hub-model` closes that gap for one exact name. A lookup
+ * costs a request, so the pointless ones are stopped here rather than sent.
+ */
+
+/**
+ * Longest name worth asking about. Ollama references are far shorter in
+ * practice; the cap keeps a paste of unbounded text away from the matcher, the
+ * same reason `formatModelDisplayName` caps its input.
+ */
+const MAX_NAME_LENGTH = 256
+
+/**
+ * `[namespace/]name[:tag]`, the form `ollama pull` accepts. Neither `/` nor `:`
+ * is in the segment character class, so each separator is the only place a
+ * repetition can start and matching stays linear.
+ */
+const OLLAMA_MODEL_REFERENCE =
+    /^[a-zA-Z0-9][a-zA-Z0-9._-]*(?:\/[a-zA-Z0-9][a-zA-Z0-9._-]*)*(?::[a-zA-Z0-9][a-zA-Z0-9._-]*)?$/
+
+/**
+ * Ollama's hosted cloud-only tags (`qwen3-vl:235b-cloud`, `gpt-oss:120b-cloud`,
+ * `…:cloud-preview`) cannot run on a local engine, so resolving one would only
+ * add a row nobody can use. The catalog scraper drops them for the same reason.
+ * `cloud` is matched as a whole delimited token, leaving `icloud-*` alone.
+ */
+function isOllamaCloudTag(name: string): boolean {
+    return /(^|[-:])cloud($|[-:])/i.test(name)
+}
+
+function isOllamaLookupCandidate(name: string): boolean {
+    return OLLAMA_MODEL_REFERENCE.test(name) && !isOllamaCloudTag(name)
+}
+
+/**
+ * Per-engine gate, keyed like the matchers in `match-downloaded-model.ts`. An
+ * engine missing from this map is never looked up, which is why LM Studio is
+ * absent: its catalog is fetched live on a six-hour TTL, so it does not fall
+ * behind between releases and has no gap to close.
+ */
+const LOOKUP_CANDIDATES: Partial<Record<EngineType, (name: string) => boolean>> = {
+    ollama: isOllamaLookupCandidate
+}
+
+/**
+ * The exact model name to resolve, or null when the query is not worth a
+ * request — an engine with no registry to ask, a query that is not a model
+ * reference, or a cloud-only tag.
+ */
+export function resolveLookupQuery(engine: EngineType | null, query: string): string | null {
+    if (!engine) return null
+    const isCandidate = LOOKUP_CANDIDATES[engine]
+    if (!isCandidate) return null
+
+    const name = query.trim()
+    if (!name || name.length > MAX_NAME_LENGTH) return null
+    return isCandidate(name) ? name : null
+}
diff --git a/desktop/src/ui/utils/model-hub-search.ts b/desktop/src/ui/utils/model-hub-search.ts
index 8111cbec..4740b32b 100644
--- a/desktop/src/ui/utils/model-hub-search.ts
+++ b/desktop/src/ui/utils/model-hub-search.ts
@@ -32,7 +32,9 @@ function hubModelToEntry(m: EngineHubModel): ModelEntry {
         author: m.author,
         url: m.url,
         size: m.size,
-        updatedAt: m.updatedAt ? new Date(m.updatedAt) : new Date(),
+        // Empty means the source reported no date; the row omits its age rather
+        // than showing the current time as a publication date.
+        updatedAt: m.updatedAt ? new Date(m.updatedAt) : undefined,
         family: m.family,
         parameterSize: m.parameterSize
     }
@@ -48,3 +50,25 @@ export async function searchEngineHub(engine: EngineType): Promise<ModelEntry[]>
     const { models } = await window.pairApi.engines.searchHub(engine)
     return models.map(hubModelToEntry)
 }
+
+/**
+ * Resolve one exact model name against the engine's own registry, for a name
+ * the catalog does not carry.
+ *
+ * Failures resolve to null rather than throwing. The user asked to search, not
+ * to make this request, so a banner about it failing would be noise — but that
+ * also swallows a broken channel, hence the warning.
+ */
+export async function lookupEngineHubModel(
+    engine: EngineType,
+    name: string
+): Promise<ModelEntry | null> {
+    if (!getEngineHub(engine)) return null
+    try {
+        const { model } = await window.pairApi.engines.lookupHubModel(engine, name)
+        return model ? hubModelToEntry(model) : null
+    } catch (error) {
+        console.warn('Model hub lookup failed', error)
+        return null
+    }
+}
diff --git a/desktop/tests/modular/model-hub-lookup.test.ts b/desktop/tests/modular/model-hub-lookup.test.ts
new file mode 100644
index 00000000..8e2830a6
--- /dev/null
+++ b/desktop/tests/modular/model-hub-lookup.test.ts
@@ -0,0 +1,74 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { describe, expect, it } from 'vitest'
+import { resolveLookupQuery } from '@/ui/utils/model-hub-lookup'
+
+/**
+ * The Ollama hub browses a committed snapshot, so a model published after that
+ * snapshot cannot be found by searching. When a search matches nothing, the hub
+ * resolves the typed name against the registry instead. These cover which
+ * queries earn that request.
+ */
+
+describe('resolveLookupQuery', () => {
+    it('accepts a well-formed model reference', () => {
+        expect(resolveLookupQuery('ollama', 'qwen3.5:32b')).toBe('qwen3.5:32b')
+        expect(resolveLookupQuery('ollama', 'gemma3')).toBe('gemma3')
+        expect(resolveLookupQuery('ollama', 'some-namespace/some-model:q4_K_M')).toBe(
+            'some-namespace/some-model:q4_K_M'
+        )
+    })
+
+    it('trims surrounding whitespace from a pasted name', () => {
+        expect(resolveLookupQuery('ollama', '  gemma3:27b \n')).toBe('gemma3:27b')
+    })
+
+    it('declines a query that is not a model reference', () => {
+        // Free-text searching is what the local filter is for; only an exact
+        // name is worth a request, because the registry has no search endpoint.
+        for (const query of [
+            '',
+            '   ',
+            'a model with spaces',
+            'has:two:colons',
+            '/leading-slash',
+            'trailing-slash/',
+            '-leading-punctuation',
+            'inject`whoami`',
+            'x'.repeat(257)
+        ]) {
+            expect(resolveLookupQuery('ollama', query)).toBeNull()
+        }
+    })
+
+    it('declines cloud-only tags, which cannot be pulled to a local engine', () => {
+        // Same rule the catalog scraper applies when it strips these rows.
+        expect(resolveLookupQuery('ollama', 'qwen3-vl:235b-cloud')).toBeNull()
+        expect(resolveLookupQuery('ollama', 'gpt-oss:120b-cloud')).toBeNull()
+        expect(resolveLookupQuery('ollama', 'deepseek-v3.1:cloud-preview')).toBeNull()
+        // The token is delimited, so a name that merely contains "cloud" stays.
+        expect(resolveLookupQuery('ollama', 'icloud-summarizer:7b')).toBe('icloud-summarizer:7b')
+    })
+
+    it('declines engines whose catalog is already fetched live', () => {
+        // LM Studio refetches from Hugging Face on a six-hour TTL, so it never
+        // falls behind a release and has no gap for a lookup to close.
+        expect(resolveLookupQuery('lm-studio', 'lmstudio-community/Qwen3-8B-GGUF')).toBeNull()
+        expect(resolveLookupQuery(null, 'qwen3:8b')).toBeNull()
+    })
+
+    it('matches in linear time on an adversarial query', () => {
+        // Neither `/` nor `:` is in the segment character class, so each
+        // separator is the only place a repetition can start. A catastrophic
+        // backtrack would blow past this budget by orders of magnitude.
+        //
+        // Kept under the 256-char cap on purpose: a longer string would be
+        // rejected on length alone and would never reach the matcher.
+        const hostile = `${'a/'.repeat(60)}${'b.'.repeat(60)}!`
+        expect(hostile.length).toBeLessThanOrEqual(256)
+        const start = performance.now()
+        expect(resolveLookupQuery('ollama', hostile)).toBeNull()
+        expect(performance.now() - start).toBeLessThan(200)
+    })
+})
diff --git a/desktop/tests/modular/ollama-registry-lookup.test.ts b/desktop/tests/modular/ollama-registry-lookup.test.ts
new file mode 100644
index 00000000..9522a5e2
--- /dev/null
+++ b/desktop/tests/modular/ollama-registry-lookup.test.ts
@@ -0,0 +1,238 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import axios, { AxiosError } from 'axios'
+import { lookupOllamaModel } from '@/electron/model-hub/ollama-registry'
+
+/**
+ * Exact-name lookup against Ollama's registry, the fallback for a model the
+ * committed catalog snapshot does not list. A lookup reads the manifest for the
+ * download size, then the config blob it points at for the model's own
+ * description of itself.
+ *
+ * `lookupOllamaModel` memoizes by name — including negative results — so every
+ * case below uses a distinct model name and a cache hit never masks a behavior
+ * under test. The one test that asserts caching does so explicitly.
+ */
+
+const CONFIG_DIGEST = 'sha256:455f34728c9b5dd9c69b6ba1dc93c0e69a1c3b2e4f5a6b7c8d9e0f1a2b3c4d5e'
+
+/** An OCI manifest shaped the way registry.ollama.ai answers. */
+const manifest = (modelLayerBytes: number, extraLayers: { mediaType: string }[] = []) => ({
+    schemaVersion: 2,
+    mediaType: 'application/vnd.docker.distribution.manifest.v2+json',
+    config: {
+        mediaType: 'application/vnd.docker.container.image.v1+json',
+        digest: CONFIG_DIGEST,
+        size: 487
+    },
+    layers: [
+        {
+            mediaType: 'application/vnd.ollama.image.model',
+            digest: 'sha256:aa',
+            size: modelLayerBytes
+        },
+        { mediaType: 'application/vnd.ollama.image.license', digest: 'sha256:cc', size: 11338 },
+        ...extraLayers.map(l => ({ ...l, digest: 'sha256:dd', size: 1000 }))
+    ]
+})
+
+/** The config blob Ollama writes, describing the model itself. */
+const config = {
+    model_format: 'gguf',
+    model_family: 'qwen35',
+    model_families: ['qwen35'],
+    model_type: '27.3B',
+    file_type: 'Q4_K_M'
+}
+
+/**
+ * Answer by URL, the way the registry does: manifests carry sizes and the
+ * config digest, blobs carry the model's description.
+ */
+const serve = (manifestBody: unknown, configBody: unknown = config) =>
+    vi.spyOn(axios, 'get').mockImplementation(async (url: string) => {
+        if (url.includes('/blobs/')) return { data: configBody }
+        return { data: manifestBody }
+    })
+
+const notFound = (): AxiosError => {
+    const err = new AxiosError('Request failed with status code 404')
+    err.response = {
+        status: 404,
+        statusText: 'Not Found',
+        data: 'not found',
+        headers: {},
+        config: { headers: new axios.AxiosHeaders() }
+    }
+    return err
+}
+
+afterEach(() => {
+    vi.restoreAllMocks()
+})
+
+describe('lookupOllamaModel', () => {
+    it('resolves a model and reports the total bytes the engine downloads', async () => {
+        serve(manifest(4_920_738_944))
+
+        const found = await lookupOllamaModel('resolve-test:8b')
+
+        expect(found?.name).toBe('resolve-test:8b')
+        // Every layer, not just the weights — that is what lands on disk.
+        expect(found?.size).toBe(4_920_738_944 + 11338)
+        // Ollama shows the manifest's config digest, shortened.
+        expect(found?.digest).toBe('455f34728c9b')
+        // Neither the manifest nor its headers carry a publication date; empty
+        // means unknown so the row hides its age rather than inventing one.
+        expect(found?.modified_at).toBe('')
+    })
+
+    it('describes the model from its config blob rather than from its tag', async () => {
+        serve(manifest(1000))
+
+        const found = await lookupOllamaModel('config-test:27b-coding-mxfp8')
+
+        // A tag is a label the publisher chose; the config carries the figures.
+        expect(found?.details.parameter_size).toBe('27.3B')
+        expect(found?.details.quantization_level).toBe('Q4_K_M')
+        expect(found?.details.format).toBe('gguf')
+        expect(found?.details.families).toEqual(['qwen35'])
+    })
+
+    it('falls back to the tag when the config states no parameter size', async () => {
+        // Ollama's MLX builds carry no `model_type`.
+        serve(manifest(1000), { model_format: 'safetensors', file_type: 'nvfp4' })
+
+        const found = await lookupOllamaModel('mlx-fallback-test:27b-mlx')
+
+        expect(found?.details.parameter_size).toBe('27b-mlx')
+        expect(found?.details.quantization_level).toBe('nvfp4')
+    })
+
+    it('reads vision off the projector layer, and claims no other capability', async () => {
+        serve(manifest(1000, [{ mediaType: 'application/vnd.ollama.image.projector' }]))
+        expect((await lookupOllamaModel('vision-test:27b'))?.details.family).toBe('vision')
+
+        // Tools and thinking come from ollama.com's rendered page and have no
+        // manifest equivalent, so a model without a projector claims nothing
+        // rather than claiming something wrong.
+        serve(manifest(1000, [{ mediaType: 'application/vnd.ollama.image.template' }]))
+        expect((await lookupOllamaModel('no-vision-test:8b'))?.details.family).toBe('')
+    })
+
+    it('still resolves when the config blob cannot be read', async () => {
+        vi.spyOn(axios, 'get').mockImplementation(async (url: string) => {
+            if (url.includes('/blobs/')) throw new Error('blob unavailable')
+            return { data: manifest(2048) }
+        })
+
+        // The size is the part that matters; the description is a bonus.
+        const found = await lookupOllamaModel('no-config-test:8b')
+        expect(found?.size).toBe(2048 + 11338)
+        expect(found?.details.parameter_size).toBe('8b')
+    })
+
+    it('implies the library namespace and the latest tag, like `ollama pull`', async () => {
+        const get = serve(manifest(1000))
+
+        await lookupOllamaModel('bare-name-test')
+
+        expect(get.mock.calls[0][0]).toBe(
+            'https://registry.ollama.ai/v2/library/bare-name-test/manifests/latest'
+        )
+    })
+
+    it('treats a dotted bare name as a model, not a registry hostname', async () => {
+        const get = serve(manifest(1000))
+
+        // Regression: the "dotted first segment is a hostname" rule that
+        // declines `hf.co/...` was once applied to lone segments too, which
+        // silently rejected most real Ollama names — `qwen3.8`, `llama3.1`,
+        // `phi3.5`. A single segment is always a name under `library`.
+        const found = await lookupOllamaModel('dotted.name.test')
+
+        expect(found).not.toBeNull()
+        expect(get.mock.calls[0][0]).toBe(
+            'https://registry.ollama.ai/v2/library/dotted.name.test/manifests/latest'
+        )
+    })
+
+    it('addresses a namespaced model without rewriting its namespace', async () => {
+        const get = serve(manifest(1000))
+
+        await lookupOllamaModel('some-user/namespaced-test:q4')
+
+        expect(get.mock.calls[0][0]).toBe(
+            'https://registry.ollama.ai/v2/some-user/namespaced-test/manifests/q4'
+        )
+    })
+
+    it('resolves a missing model to null without raising', async () => {
+        vi.spyOn(axios, 'get').mockRejectedValue(notFound())
+
+        // A lookup is speculative, so "not there" is an answer, not an error.
+        await expect(lookupOllamaModel('missing-model-test:1b')).resolves.toBeNull()
+    })
+
+    it('resolves to null when the registry cannot be reached', async () => {
+        vi.spyOn(axios, 'get').mockRejectedValue(new Error('getaddrinfo ENOTFOUND'))
+
+        await expect(lookupOllamaModel('offline-test:1b')).resolves.toBeNull()
+    })
+
+    it('declines a reference belonging to another registry', async () => {
+        const get = vi.spyOn(axios, 'get')
+
+        // A dot in the first of several segments is a registry hostname. This
+        // registry cannot answer for it, and asking would report a real model
+        // as missing.
+        await expect(lookupOllamaModel('hf.co/some-user/some-repo:Q4_K_M')).resolves.toBeNull()
+        expect(get).not.toHaveBeenCalled()
+    })
+
+    it('refuses a name that would steer the request URL', async () => {
+        const get = vi.spyOn(axios, 'get')
+
+        // The renderer screens queries before asking, but a lookup arrives over
+        // IPC and this runs in main, so it screens its own input. Unchecked,
+        // `foo/..` walks out of the namespace and `foo/bar#z` truncates the
+        // path, both landing on an endpoint nobody asked for.
+        for (const hostile of [
+            'foo/..',
+            'foo/bar?x=1',
+            'foo/bar#z',
+            'foo/bar:tag#z',
+            '../etc',
+            'foo//bar',
+            'foo/bar:'
+        ]) {
+            await expect(lookupOllamaModel(hostile)).resolves.toBeNull()
+        }
+        expect(get).not.toHaveBeenCalled()
+    })
+
+    it('declines a manifest that reports no layers rather than showing a 0-byte model', async () => {
+        serve({ schemaVersion: 2, layers: [] })
+
+        await expect(lookupOllamaModel('empty-manifest-test:1b')).resolves.toBeNull()
+    })
+
+    it('caches both answers so typing past a resolved name does not refetch', async () => {
+        const get = serve(manifest(2048))
+
+        const first = await lookupOllamaModel('cache-test:8b')
+        const second = await lookupOllamaModel('cache-test:8b')
+
+        expect(second).toBe(first)
+        // Manifest plus config blob for the first call, nothing for the second.
+        expect(get).toHaveBeenCalledTimes(2)
+
+        get.mockRejectedValue(notFound())
+        await expect(lookupOllamaModel('cache-miss-test:8b')).resolves.toBeNull()
+        await expect(lookupOllamaModel('cache-miss-test:8b')).resolves.toBeNull()
+        // One more call for the first miss; the second is served from the cache.
+        expect(get).toHaveBeenCalledTimes(3)
+    })
+})