---
title: Quick search (⌘K) across every app
description: How ⌘K finds notes, issues, people, deals, flags, support tickets, chat and more in one search, what each app matches, how results are ranked, and the streamed search API behind it.
section: cloud
order: 6
audience: [user, operator, builder]
features: [cloud.api-workspace]
sources: [services/nodejs-cloud/lib/workspace/search.ts, services/nodejs-cloud/lib/workspace/federate.ts, services/nodejs-cloud/lib/workspace/rank.ts, services/nodejs-cloud/lib/db/textmatch.ts, services/nodejs-cloud/lib/support/quick.ts, services/nodejs-cloud/lib/incidents/quick.ts, services/nodejs-cloud/components/workspace/Palette.tsx, services/nodejs-cloud/components/workspace/search-client.ts, services/nodejs-cloud/app/api/workspace/search/route.ts, services/nodejs-cloud/migrations/0274_search_trgm.sql, services/nodejs-cloud/migrations/0275_errors_issues_title_trgm.sql, services/nodejs-cloud/migrations/0277_support_subject_trgm.sql]
---

⌘K (Ctrl+K) searches every app in your workspace at once (in Tasks, where ⌘K is the Tasks command menu, use ⌘P or
the menu's **Search everything**). The [workspace page](/docs/cloud/workspace.md)
covers opening it and the keys; this page covers what it searches, how it ranks, and the API.

## What you see while you type

The first keystroke answers from your browser, before the server does: pinned items, recently opened items, the
apps, actions such as "New note", and the organisation's settings pages, gears, models, keys and members. Server
results follow a moment later and fill in group by group as each app answers, so one slow app never holds up the
others. When an app misses an answer (it failed or ran out of time), ⌘K asks that app again once, on its own, and
adds its results when they come.

Backspacing never asks the server again: answers are kept for a minute. While a longer query loads, the answer for
the shorter one is narrowed and shown at once.

Each result shows an icon, its title with the matched letters marked, and a context line under it (the vault and
folder of a note, an issue's state and team, a person's company). Groups are ordered by their best result, so the
app that matches best comes first. Each group shows up to five results; when an app has more, a **Show all in
&lt;app&gt;** row narrows the search to that app (up to 20 results).

| Key | What it does |
|---|---|
| ↑ ↓ | Move between results (they wrap around) |
| Home, End | First or last result |
| Page Down, Page Up | Move a page of results |
| ↵ | Open the result |
| ⌘↵ (Ctrl+↵) | Open the result in a new tab |
| ⌘C (Ctrl+C) | Copy the result's link (with text selected in the box, copies the text) |
| ⌥P | Pin or unpin the selected result (pins come first with nothing typed, up to 12, per organisation, in this browser) |
| Tab, ⇧Tab | Narrow to one app, or back to everything |

A new search highlights its best result. Results that arrive while you read leave the highlighted one where it is. `Esc`
closes ⌘K and puts you back where you were; while an input method is composing a character, `Esc` and the arrows belong
to it.

It works the same on a phone, in the installed app and on a desktop.

## What each app matches

Matching is on titles and names, not whole documents (the apps' own searches do full text). Each word you type must
match: a word start or a part of a word ("roadm" finds "Roadmap", "deplo" finds "Deploy checklist"). When nothing or
little matches, a near spelling is tried ("lanch" finds "Launch plan").

| App | Prefix | Matches |
|---|---|---|
| Notes | `notes:` | note titles in the vaults you can read |
| Issues | `tasks:`, `issues:` | issue titles, and an identifier such as `ENG-12` exactly; private teams stay hidden |
| Flags | `flags:` | flag keys and names, in every project |
| Incidents | `incidents:`, `errors:` | incident titles and error issue titles |
| Forms | `forms:` | form titles |
| Experiments | `exp:` | experiments and metrics |
| People | `@` | people's names (a private person only for their owner) and members' names and emails |
| Funnel | `deals:` | deal titles and companies |
| Calendar | `calendar:` | event types, and bookings by the invitee's name |
| Support | `support:`, `tickets:` | ticket subjects, and a ticket number (`#42` or `42`) exactly; a private team's tickets stay hidden |
| Chat | `chat:`, `#` | channels you can see, your direct messages, and words in messages |
| Computers | `computers:` | computers and seats |
| Studio | `studio:`, `deck:` | decks, pages and HTML pages you may read, by title and text |
| Status page | `status:` | status page incidents and changelog entries (for roles that can open the status page settings) |
| Admin | `admin:` | settings pages, quick actions, docs |
| Actions | `>` | things you can do, such as "New issue" |

You see only what you could open in the app itself: the same vault, team, privacy and role rules apply, and an
app your organisation does not have is skipped. A support ticket assigned to a private team shows only for that
team's members and the organisation's owners and admins, as in Support's inbox.

## Ranking

Within a group, an exact title beats a title that starts with what you typed, which beats a word start, which beats
a part of a word, which beats a near spelling. Small boosts then favour what you opened recently, what you own, and
what changed recently (the boost halves every two weeks). An exact identifier or key (`ENG-12`, a flag's key) goes
first. A ticket number (`#42`) goes first in Support's group the same way.

## Speed

Every app is searched in parallel, each with a 300 ms limit; an app that runs over is left out of that answer
rather than slowing the rest, and ⌘K asks it again once on its own. Titles are indexed for part-of-word and
near-spelling matches (Postgres `pg_trgm` indexes, migrations 0274, 0275 and 0277).

Each title match runs in a short read-only transaction that tells Postgres to use those indexes (no sequential scan,
no JIT) and, for a near spelling, sets the similarity it needs. Without that, Postgres often read every row of the
organisation: it prices a trigram test like a cheap comparison. On a test database with 20,000 rows in every app, the
whole search went from 35 ms at the median and 98 ms at the 95th percentile to 17 ms and 27 ms. Near-spelling
searches gained the most: one app's took 35 to 70 ms before and takes under 6 ms now.

### The first search on a cold server

A server that has just started, or has been idle for a few seconds, has no database connections open. Each app then
opens its own before its first query (the network handshake, signing in, and a database that was asleep waking up),
which took longer than 300 ms, so the first answer used to come back empty. Three things fix that:

- When ⌘K opens, it asks the server to get ready: load the search code and open the database connections. You are
  still typing the first letters while that happens.
- A search that starts on a cold server gives every app up to 2.5 seconds instead of 300 ms. Results still stream in
  as each app answers.
- Any app that still misses the answer is asked again once, on its own, and its results join the list.

The search runs on Venom Cloud's own database. Nothing is sent to a hosted search service, and queries are not
logged.

## The search API {#api}

`GET /api/workspace/search?q=<text>[&app=<app>][&apps=<app>,<app>][&stream=1]` is what ⌘K calls. `app` is one of
`notes`, `issues`, `flags`, `incidents`, `forms`, `experiments`, `people`, `funnel`, `calendar`, `support`, `chat`,
`computers`, `studio`, `status`, `admin`, and narrows the search to that app with up to 20 results. `apps` searches only the
listed apps, with the usual few results each: ⌘K uses it to ask again for the apps an answer left out.
`GET /api/workspace/search?warm=1` loads the search code and opens database connections, and answers 204 with no
body; ⌘K sends it when it opens, at most every 20 seconds. It works only from a signed-in browser on Venom Cloud's own site (a cross-site request gets 403, a
signed-out one a JSON 401); scripts and agents use `workspace_item_search` on the
[workspace MCP server](/docs/cloud/workspace-mcp.md) or each app's API.

Without `stream`, it answers once:

```json
{ "groups": [{ "app": "notes", "best": 0.9, "more": false, "items": [{ "id": "…", "title": "Roadmap", "context": "Org vault · Plans", "href": "/globe/vault/…", "score": 0.9 }] }], "took": 18 }
```

With `stream=1` it answers `application/x-ndjson`: one `{"group": …}` line as each app answers, then
`{"done": true, "took": 18, "order": ["notes", "issues"]}` with the final group order. `more` says the app has more
results than were sent. The `done` line also carries `skipped` (the apps that failed or ran out of time) when there
were any, and `cold: true` when the search started on a cold server.
