---
title: Get Help (Helpdesk)
---

# Get Help (Helpdesk)

## What it is

The **Get Help** panel is a conversation-style assistant inside Agent Mission
Control. Ask anything — questions about the app are answered using its own
help documentation with **clickable source chips** linking to the exact help page,
while general questions (writing a follow-up email, explaining a concept) get a
helpful answer without any source citations. The model self-identifies which kind
of answer it's giving.

Get Help opens as a **small floating chat widget in the corner of the screen**
— it's non-modal, so the rest of the app stays visible and interactive behind
it, and it never takes over the whole window unless you ask it to. On desktop
it's anchored to the bottom-left corner by default (the separate Support Chat
widget lives in the bottom-right), a **move button in the widget's header**
flips it to the other side of the screen (left ↔ right — the choice persists
across restarts), and a **full-screen button** expands it into a
console that fills the app below the title bar (so Omniscio's own window
controls stay put): your conversation list on the left (admins get a
Conversations / Needs-your-reply switch) and the open chat beside it. For an
admin with a thread open, a **details rail** fills a third column on the right
— the sender's contact card (avatar, name, email, plan), then the conversation's
private **tags** (add, colour and remove them right there — they sit at the top
so a conversation can be tagged without scrolling), then the same user's **other
conversations** (click one to switch to it), who it is assigned to, the
conversation's status and activity times, the sender's local time / time zone /
language and their app version + OS (when the escalating app stamped them; older
threads fall back to the "System info" note in the thread), which admins have
replied, and — at the foot — the admin's private notes. The two
outer columns are **yours to size**: drag the divider beside the conversation list
or the one beside the details rail and each keeps its own width across restarts
(double-click a divider to put that column back to its default), or focus a divider
and use the arrow keys. The chat in the middle always takes whatever space is left.
Who
the conversation is with and its status also show at the top of the chat itself;
on mobile it goes full-screen. While the console is full-screen the **"Help Desk
Console" row in the app's far-left navigation** is highlighted to show that's
where you are — and clicking anything else there (a project, the
Inbox, Settings) simply **closes the Help Desk** and takes you to that page, so
you're never stuck on the Help page when you try to navigate away. The console
never shrinks into the small corner widget: it has no exit-full-screen button,
and ✕ or Esc closes it. Inside, a small
header has: **Chat** (the default view — a composer ready to type into),
**Help Center** (browse the help articles), **Insights** (a small analytics
dashboard — see below), and — for developers only — **Needs your reply** (the
escalation queue, with a count badge; each waiting row shows the question, the
reporter's name and email when they were signed in, and the date and time it
arrived). **Your Get Help is a single ongoing conversation** — there is no
History list and no "New conversation" button; whenever you open Get Help you
land back in that one continuous conversation and anything you type is a
follow-up in it. A developer thread in Needs your reply
opens right in the chat body — while it loads
(and while a first question is being answered) the chat shows just your
message with a small typing indicator. Messages render through the **same chat
rendering a regular Omniscio conversation uses** — the same bubble shapes, the
same markdown engine — with your own on the right and the assistant or developer
on the left, each beside the sender's avatar (your profile photo when you're
signed in, a friendly bot mark for AI answers, initials otherwise).

You can send **follow-up messages** within a conversation — the AI answers with
the full thread context. If the AI answer didn't help, a "Send to developer" button
escalates the conversation. For a developer (with the dev-console gate enabled),
escalated questions from users show up in the **"Needs your reply" view**,
switched to via its own header icon. Opening a thread there shows it in the
same chat body (the developer's own replies sit on the right, like any normal
chat). The reply arrives as a **toolbar badge + OS notification** and appears
in the chat view within a few seconds — while a conversation is waiting on the
developer the app checks for replies on a fast cadence, and opening the Get
Help panel checks immediately.

## Where to find it

### How to open it

- Press **Ctrl+Shift+H** — the Get Help widget pops in at the bottom-left of
  your screen (bottom-right if you've moved it via the header's move button;
  full-screen on mobile).
- Click the **LifeBuoy icon** in the toolbar (appears when the feature is
  enabled), or find it in the overflow menu.
- Click **Help Desk** in the projects sidebar — an ordinary hub row alongside the
  other integrations, not a fixed slot of its own. The row is always there while
  Get Help is enabled, highlights while the panel is open, and carries the same
  unread count as the toolbar button. (A separate **Help Desk Console** row sits
  right beside it for a seat that holds the admin console —
  see [part 2](helpdesk-part-2.md).)

> **Note:** Get Help is currently an in-development feature and is hidden by
> default. Developers can reveal it by launching Omniscio with the environment
> variable `AMC_SHOW_HELPDESK=1`, or by flipping the Labs toggle in Settings
> once it appears there. Most users will not see it until a future release
> enables it for everyone.

## How it behaves

### Full lifecycle

```
User asks a question
  → AI answer (Omniscio-scope with source chips, or general-scope without)
  → The answer shows in your single ongoing conversation
  → Rate 👍 or 👎 — feedback only; rating never changes the conversation's status

User sends follow-up
  → AI answers with thread context (up to 20 prior messages)
  → Scope may widen general → Omniscio (never narrows)

If the AI answer didn't help (Omniscio-scope only):
  → User clicks "Send to developer"
  → Status: waiting_dev
  → Escalation email sent via resend-service, resolved server-side; its subject
    carries a snippet of the question so each alert is its own email conversation
    (temporarily routed to a single developer inbox — 2026-07-22 owner request;
    normally the owner plus each admin account)
  → Subsequent messages in the chat go to the developer, not AI

Developer (on their machine, gated "Needs your reply" view):
  → New question (or a user follow-up re-queuing a thread) raises a desktop
    notification with a chime, even when Omniscio is in the background —
    clicking it brings the app forward and opens the waiting thread
    (plus an in-app inbox alert and a phone push if a phone is paired)
  → Opening that in-app inbox row lands on the console showing **that** thread.
    An explicit "open this question" outranks the console's load-on-open habit of
    resuming the developer's own most-recent conversation — needed because those
    two share one selection slot, so the resume would otherwise discard the thread
    the row pointed at (and on a single-user install the developer IS a user, so
    they have a most-recent conversation to resume)
  → Opens Get Help widget → clicks the "Needs your reply" header icon → lists waiting questions, load-on-open + Refresh
  → Opens thread → reads question + AI attempt → types reply → sends
  → Status: answered (in cloud); thread refreshes in list
  → When the exchange is done, clicks "Mark resolved" — or presses **E** — to
    close it, and the console moves straight on to the next conversation in the
    queue (the one below, else the one above; none left → an empty console) — and
    "Mark unresolved" reopens a resolved thread, landing it where the last
    speaker left it (customer spoke last → back in the Pending queue;
    developer spoke last → Awaiting customer). Typing a reply
    into a resolved thread reopens it automatically, so a follow-up never
    lands on a closed conversation.

User receives reply:
  → Push listener refreshes the chat view + conversation list in real time
  → Desktop notification with a chime: "Developer replied to your question" —
    clicking it brings the app forward and opens the replied conversation
    (a phone push is sent too if a phone is paired)
  → Inbox notification: "Developer replied to your question"
  → Developer reply shown as accent-tinted bubble in chat

User sends follow-up on escalated thread:
  → Status flips back to: waiting_dev (in cloud AND locally)
  → Thread reappears in the developer's "Needs your reply" view on next open/refresh
  → Developer follow-up alert email sent

Developer resolves (or reopens):
  → "Mark resolved" (or **E**) closes the thread and opens the next conversation
    in the queue; "Mark unresolved" reopens it to wherever the last speaker left
    it (waiting_dev or answered)
  → **E** is the console's resolve key: it works on the conversation that is open,
    never while you are typing in a box (or in the moment after), never with
    Ctrl/Alt/Shift/Cmd held, and never inside a menu or dialog. Hovering Mark
    resolved shows the key. While the full-screen console is open, single-letter
    keys never reach the app behind it — E there can never archive a session
  → A hairline divider marks the resolve/reopen in the developer console only;
    the user's chat shows a single muted "Marked Resolved" note while resolved
  → In the console, a resolved conversation's row (the queue, the Resolved view,
    the person's other conversations, and search) previews its question, not
    the resolve note or a closing line; an open one previews its latest message
  → The user's local copy flips to resolved too; their next message on it goes
    back to the AI (and they can re-escalate afresh)
  → Resolution is a developer action now — the user no longer has a resolve button
```

No AI is involved after escalation — developer messages come from the developer
console only (or the in-memory fake seam in tests).

**Who sees which developer replied.** Every developer reply is stamped
server-side with the replying admin's identity (from their verified sign-in —
a client can't forge it). The user sees the developer's **first name only** —
a reply reads "Alex" instead of the generic "Agent" label, which is friendlier
without identifying the teammate: the relay that delivers replies to users
strips the full identity (email, account id) server-side and passes through
just the first name, on both the push and the poll delivery paths. The full
attribution is **admin-console-only**: in the "Needs your reply" thread view,
your own replies are labeled "You" and another admin's replies are labeled with
their email, so a team of developers can see who answered what.
Replies sent before this feature carry no name and render as "Agent".

**Conversations are private to your account.** Your Get Help history belongs to
the account that asked: each conversation is tagged with the signed-in account
that created it, and every list and lookup returns only your own. A second
person signing into the same computer sees their own (empty) history, not
yours — and switching accounts also clears the developer-side incoming-alert
cache on that machine. Conversations started while signed out belong to the
signed-out state only: they show while you are signed out and are not carried
into any account when someone signs in — signing back out shows them again.
If a send
to the agent fails (for example, offline), the message is not kept locally —
retrying sends it once, never as duplicates.

**Resolve/reopen markers.** When the developer marks your conversation
resolved (or reopens it), your copy updates quietly: the conversation's status
flips, with no desktop notification or chime. While a conversation is
resolved, a single muted **"Marked Resolved"** note shows at the end of your
chat; reopening removes it. The per-event resolve/reopen hairline dividers are
**developer-console-only** — the back-and-forth of resolving and reopening is
support-side bookkeeping and is deliberately not replayed in your chat.
Once a conversation is resolved, typing a new message hands it **back to the
AI** — you get an instant AI answer again, and you can send it to the developer
afresh if you still need a human.

### How answers work

When you submit a question, the app:

1. Searches its bundled help documentation (`docs/llm-library/`) for the most
   relevant pages.
2. Sends your question — along with those pages as context — to an AI model
   (`source: 'helpdesk-ask'`; a single `llmProviderService.chat()` call, no session
   spawn).
3. Returns a plain-language answer together with **source chips**: small tags
   naming the exact help pages the answer was drawn from. **Click any chip** to
   open that help page in the Help & Docs panel (chips are hidden if the page
   cannot be resolved).

If your question is about Omniscio but not covered by the docs, the answer will say so
honestly rather than guessing (`covered: false`, empty source list — a
"couldn't find it" answer never shows source chips). If your question is general
(not about the app), the assistant answers it as a helpful AI — no source chips,
`scope: 'general'`.

### What the AI answer path needs

The model call pins `provider: 'openrouter'`, whose baked company key is
retired — the call is developer-paid **through the cloud gateway**, which needs
the Omniscio cloud (global-auth) sign-in. Without a gateway session the provider
layer degrades to its Anthropic backstop, which needs an **Anthropic API-key
account**; a subscription-only (OAuth) Claude sign-in cannot use the Messages
API directly. When BOTH of those are missing but a healthy **Claude
subscription login** is signed into Omniscio, the assistant still answers: it runs
the question through a one-shot Claude Code print call on the user's own plan
(the same subscription bridge the Council and Writer features use) — no API
key, no extra dollars, slightly slower than the direct API. Only when there is
no gateway session, no API-key account, AND no subscription login does the
assistant reply with a friendly "can't reach its AI service" message (never
the raw `AnthropicFallbackUnavailableError`). That error area still helps two
ways, because neither needs an AI credential: a **"Send to developer" button**
(one click creates the conversation from your question and sends it through
the helpdesk relay) and, when the local doc search found candidates, a row of
**clickable help-page links** ("these help pages might have the answer") that
open the Help & Docs panel at the matching section. In a dev checkout the missing-gateway case most often means
`default-credentials.local.json` was never materialized
(`npm run secrets:pull`), so the global-auth config that enables the gateway
sign-in is missing.

### Things you can do with a conversation

- **Copy an answer.** Every AI answer and every developer reply has a small
  **copy button** — click it to put the full message text on your clipboard; it
  briefly shows a "Copied" confirmation.
- **Rate — and change your mind.** The 👍 / 👎 rating is **reversible**: your
  chosen rating stays visibly pressed, and you can switch it or clear it at any
  time. Rating is **feedback only** — it no longer resolves the conversation
  (whether a support conversation is resolved is the developer's call).
- **Click a source chip.** Source chips always **open the Help & Docs panel** at
  the exact page the answer drew from (opening the panel if it's closed). A chip
  is **hidden** whenever its page can't be resolved — including when the cited
  doc has no page on the public help site — so you never get a dead click.
- **One ongoing conversation.** Get Help keeps a single continuous conversation
  for you — there's no list of past conversations to browse, no "New
  conversation" button, and no per-conversation delete or history search on the
  user side. Opening Get Help always returns you to that one conversation, and
  anything you type continues it. (Developers still get the full queue browse,
  search, and filters below.)
- **Search & filter the queue (developers).** The developer console's queue has
  its own search box beside the queue-view menu. The menu offers All, Unread,
  Pending, Unresolved, Resolved, Most Recent, and Longest Waiting views. Every
  view shows one row per person (their newest conversation) EXCEPT **Resolved**,
  which is the history of past conversations: every resolved conversation gets
  its own row, newest first, even when the same person has an open one. Search
  matches the question, the person's name or email, the row's preview, and your
  private tags. One clickable chip appears per tag in use; pick one or more to
  narrow the current view (chips combine with search). Tags and their filters
  are private to the console and never leave the developer's machine.
- **Drafts survive a failed send.** If a message fails to send (yours or, for
  developers, a reply), your typed text stays in the composer so you can retry
  without re-typing — the retry re-sends that exact message. Pressing **Esc**
  while the composer still has text just moves focus out of it rather than
  closing the whole panel, so you can't lose a draft by accident.

### What gets attached when you escalate

When you send a conversation to the developer, Omniscio automatically attaches a short
**system-info line** — your Omniscio version and operating system, e.g.
`Omniscio v1.2.3 · win32 10.0.19045` — to both the alert email and the conversation
the developer sees, so they can triage without asking you what you're running.

Escalation is only offered for **questions about Omniscio**. On a general-knowledge
conversation the panel shows a short caption explaining that "Send to developer"
is for app questions only.

### Rate limit

The panel is limited to **10 questions per minute**. If you reach the limit, an
inline message shows a **live countdown** of the seconds remaining, ticking down
until you can ask again — so you're never left guessing when the panel will
accept another question. The countdown recovers correctly even if your computer's
clock jumps backward.

### Insights

The **Insights** view (the bar-chart icon in the header) is a small, read-only
dashboard summarising how Get Help is being used **on this computer**. It shows:

- **Questions** — how many questions were asked in the selected window.
- **Handled by AI** — the share the AI answered without ever escalating to a
  human (the self-service _deflection rate_), with how many still needed a
  person.
- **Satisfaction** — of the answers you rated 👍/👎, the share that were 👍
  (with how many of the total were rated).
- **Questions over time** — a simple trend line of daily volume.

A **30 days / 90 days / All time** switch at the top scopes every figure. Until a
few questions have been asked, it shows a friendly empty state.

Insights is **entirely local and free**: it only reads the questions already
stored on your machine — it makes no AI call, sends nothing to the cloud, and
costs nothing. It shows only _your own_ questions, so (unlike "Needs your reply")
it needs no developer/admin access — anyone who can see Get Help can open it.

> **Phase 1 note.** Insights currently summarises just this install's own
> questions. A future phase may roll the numbers up across all users of a
> deployment; that needs additional cloud plumbing and is tracked separately.

### Feature gates

There are two separate gates, both using the standard unreleased-feature registry:

| Gate                   | env var                           | settings key                | Purpose                                                                       |
| ---------------------- | --------------------------------- | --------------------------- | ----------------------------------------------------------------------------- |
| `helpdesk`             | `AMC_SHOW_HELPDESK=1`             | `helpdeskEnabled`           | Entire Get Help feature (user-facing)                                         |
| `helpdesk-dev-console` | `AMC_SHOW_HELPDESK_DEV_CONSOLE=1` | `helpdeskDevConsoleEnabled` | Adds the "Needs your reply" header icon + view to the widget (developer only) |

The `helpdesk-dev-console` gate stays `'in-development'` even after `helpdesk`
ships — ordinary installs never see the developer console. Both gates are checked
in Main (not just in the renderer), so hiding them client-side is not the only
barrier. Access is now **server-enforced**, not just client-gated: every
developer-console read/write routes through the admin-authed `operatorConsole`
Cloud Function (verified Firebase ID token + `requireAdmin` from signed claims),
so the shipped Firebase admin service account key is retired from the helpdesk
operator surface.

## For agents

The rest of the Helpdesk — the operator queue's own views and filters, the developer console's status tabs, drafts, routing and aging rules, the boot-time reply listener and the incoming-question watcher, the test seams, and the key files — is in [Get Help (Helpdesk) (part 2)](helpdesk-part-2.md).

## Related

- [keyboard-shortcuts.md](keyboard-shortcuts.md) — full list of Omniscio keyboard
  shortcuts, including Ctrl+Shift+H
- [ask-amc.md](ask-amc.md) — a separate feature that lets you have a full
  back-and-forth chat with Claude about the app, with the ability to configure
  settings for you
- Omniscio’s unreleased-feature (“Lab”) gate — how Omniscio hides
  in-development features until they ship
- [report-conversations.md](report-conversations.md) — every report sent from the
  Feedback button opens a conversation the support team answers here; the reporter
  reads the replies under "Your reports", even with Get Help off