Omniscio

Ask Omniscio — in-app help agent

The sidebar help agent that answers questions about Omniscio from the bundled library and your live state: which model it runs on, what it knows and can do, the question log, the privacy model, and its v1 limits.

On this page

What it is

Ask Omniscio is a sidebar virtual project that hosts normal Claude CLI sessions pre-seeded with the Omniscio LLM library and a live view of your Omniscio state. Each chat finds and shows: it answers "how do I X?" / "what is X?" questions in plain language, and for a change request it locates the exact feature and setting, says what to change, and puts it one click away (GET /settings/open?q=…). It holds two credentials the app mints for it — a scoped read token and a separate action credential — and never borrows a stronger one. Every setting it changes applies at once; the few the app holds for your own decision (see What the agent can do) it hands you a jump to instead, and the agent never describes a hand-off as a change it made. Parallel chats are supported and independent (no cross-chat memory in v1). It is on by default; turn it off in Settings → Features.

Where to find it

How to use it

  1. Find it in the sidebar. Ask Omniscio is on by default. It is a fixed row in the top zone of the side nav, right after Inbox and Claude — the flagship helper, always one click away. To turn it off, open Settings → Features → flip off Enable Ask Omniscio (in-app help agent). Toggling off is non-destructive — chats and history stay on disk; the sidebar simply hides them. Toggle back on and they reappear intact. Ask Omniscio is fixed in that top zone: it cannot be pinned, dragged into a folder or removed from the side nav, and it does not count toward the five pins.

    Three ways in, so you never have to hunt for it. Besides the side nav row there is a top-bar button (the speech-bubble-with-a-question-mark icon, grouped with Help & Docs) and a keyboard shortcut Ctrl+/ that works anywhere in the app, including while you type in a composer. Hovering the button shows the live shortcut as a key-cap, and it is listed in the ? overlay and in Settings → Keybindings, where you can rebind it. The button is on the header by default; switching Ask Omniscio off removes all three doors.

  2. Start a chat — click the Ask Omniscio entry. Clicking it drops you straight into a session. If a previous chat is waiting on you (a question, an error, or a stalled run), you land on it; otherwise you land in a fresh blank chat with the textarea focused. The "+" on the project row still creates a new chat alongside an existing one. Chats run as normal Omniscio sessions — status flow, inbox row, snooze / archive / pause / Send Later, notifications, all unchanged.

  3. Ask anything — or ask to be shown. "What's the difference between Snooze and Pause?", "What sessions need my attention right now?", "How do I schedule a cron pinging my main inbox every Monday at 9am?" The agent reads the library, queries your live state, and makes the change with its own action credential — applying a setting immediately, or handing you a jump to one the app holds for your own decision (see What the agent can do).

  4. It finds the exact setting, makes the change, and reads every part back. A vague ask ("the box I type in feels dumb", "my session names are terrible") is turned into the setting that names the behaviour — aiSuggestionsEnabled, sessionTitleCustomRefresh — through GET /settings?q=<two or three words>, which returns every setting whose name matches with the value it holds now; the Settings box's own search and the library page's For agents block are the fallbacks. A setting is then applied and read back for you: the write answers with the value the app holds after it, plus whether that is the value you asked for, so a two-part request is reported part by part and any part that did not take is named rather than glossed. A rule needing review arrives as an approval card: nothing has changed until you approve it, and the agent says so rather than claiming it is done. A key refused outright comes back as the exact setting, its current value, and a one-call jump (GET /settings/open?q=…) that moves you there or shows a Go there button.

  5. Open multiple chats. Each chat is a fresh session: use one for "what is this feature" questions, another for "configure this for me" tasks, a third while the first two run. They don't share memory.

How it behaves

The model it runs on (yours first, ours as the safety net)

Ask Omniscio runs on your own Claude model first — the same model behind your other sessions — so it answers as well as any other agent.

Which model, exactly — and you can choose. Out of the box it runs on a top-tier model (Opus class), not whatever your other new sessions default to: a help agent that answers badly when you need help is worse than none. You can pick another in Settings → Sessions → Ask Omniscio model, from the same model list every other model setting uses, or leave it on Automatic for the top tier. If your Claude CLI is older than the shipped model needs, it steps down to a model that actually runs rather than failing to start.

If you have no Claude credentials of your own, it falls back to a built-in, company-paid model: DeepSeek V4.1 Flash for typed questions, and Claude Haiku for screenshots, PDFs and retrying a typed question the lane could not answer — the image paths stay on Claude, since DeepSeek 4.1 reads no images — so the help agent still works. That is the "never breaks" guarantee: a working helper whether or not you can run one yourself.

Changed 2026-08-06. Ask Omniscio used to prefer the built-in company model for everyone, to protect your Claude usage. That made it noticeably weaker for people already paying for a strong model, so the order was flipped: your model first, ours as the safety net.

Your default AI, whichever it is. Ask Omniscio runs on the AI you normally use — Claude, Codex, Gemini, or a Claude-compatible service like DeepSeek — with the same help library and instructions on each. If that AI isn't set up here (not installed, switched off, or not signed in), it answers with Claude instead and says so in one line. On anything other than Claude it is told never to create, edit or delete files (on Claude, editing is blocked outright).

Fixed 2026-10-09. A brand-new install signs you in "with the Claude login on this computer" by default. Ask Omniscio used to treat that choice as "you have your own AI" even when no Claude login existed — so it skipped the built-in model and could not start at all. It now checks for a real login (including one whose short-lived pass has expired but can renew, and on a Mac the login Claude Code keeps in the Keychain) and uses the built-in model when there is none.

If you have bought Omniscio credits, Ask Omniscio can run on them. With no AI account of your own set up here and money on your Omniscio credit balance, Ask is paid from that credit — the same credit that pays for Omniscio's other models. Your own AI account always comes first: if you have one, Ask uses it and your credit is never touched, even when that account is temporarily rate-limited or signed out. With neither credit nor an account, the company's one-off free allowance answers instead, as before.

The company lane's text model. Typed questions on the company-paid backup go to DeepSeek V4.1 Flash — the faster, cheaper model named for this lane — on the same monitored, metered path, with nothing to turn on.

Changed 2026-10-13. That lane used to run through a small translator on your own computer: Ask Omniscio spoke Anthropic to it and it re-wrote each question for the company gateway. It now points straight at the gateway's DeepSeek route, as the onboarding starter agents already do — one less moving part on the path that exists for people whose setup is already broken. Every company-paid help request now also carries the lane's identity to the gateway, which meters the spend against your own one-off company-AI grant.

When the company's AI for you runs out. Each person gets a one-time $0.25 of company-paid help, for the life of the account — a last resort, not a subscription, and it does not refill. When it is spent, Ask Omniscio says exactly that and points at the one thing that helps: connecting your own Claude account. A company-wide limit instead gets a different, honest message — nothing of yours was used up, so it does not claim otherwise.

Turning the fallback off. The setting askAmcUseCompanyModel (on by default) controls only the fallback: off = never spend company credit, so a user with no Claude credentials gets the standard "sign in" prompt instead of the built-in model. It doesn't affect you if you have your own credentials — you were never on the company model. Its Settings → Features toggle is developer-only (hidden in production builds).

Spending guardrails. The per-session spending cap applies only to the company-paid fallback, because that is our money — on your own credentials Ask Omniscio spends like any other session you run. That fallback cap is tiny by design ($0.25 per conversation, on top of the one-off per-person allowance): the company lane is an occasional hint for someone who cannot start without it, not a subsidised assistant. On company money the backup always runs its own model, ignoring a model you picked — that choice belongs to the AI account you pay for, and applies to your own credentials, where it really runs.

One backup for all three help agents. "Ask about this page" and Simple Mode's guided helper share this company-paid backup — one daily limit of company-paid starts (50 per computer per day), the same "never spend company credit" switch and the same paid-plan gate. The last-resort backup that steps in when a sign-in is broken counts against that limit too, and once it is spent no helper runs on company money until the next day. The backup only ever stands in for Claude: a helper on your own GPT, DeepSeek or other AI never moves onto it.

No file writing, ever. Ask Omniscio can't create or edit files on any path — your model or the built-in one. It's a help agent, not a builder: it reads, searches, browses the web, and takes the usual approval-gated actions. (This used to be tied to the built-in model only; it is now unconditional, so switching credentials can never quietly grant write access to your disk.)

This is also why the agent never changes a setting by editing a file — no settings.json, no config.json, no database, nothing on disk. Every change goes through the app's own API, so the running app re-reads it and the change takes effect immediately. A shell edit to a config file looks like it worked and changes nothing you can see — exactly the failure the read-back rule exists to catch.

What the agent knows

  • The LLM library. The full docs/llm-library/ tree (this file plus its siblings) is bundled into the chat's working directory on every spawn. The agent reads ROUTING.md first — the compact routing table — and pulls specific pages on demand. (INDEX.md is the same table with a summary paragraph on every row — too large to load in one read, and an agent that opens it silently sees only its first tenth, so it is told never to read it cold.) If your question isn't covered, the agent says "not in library" before answering from general knowledge.
  • The feature catalog. Before acting on a request it does not already know how to satisfy, the agent calls GET /capabilities/search?q=<the feature's own words> on the local control server. That ranks every Omniscio surface and answers with each one's best routes for that question, best-first, each with a one-line description and the token it needs on its own — so it finds the right feature instead of guessing a key, and a broad surface (the sessions family alone owns over a hundred routes) no longer buries the answer in a full route dump. &full=1 asks for a matched surface's complete route table when the shortlist misses. This is why it can answer "where is the dictation setting?" with the dictation setting. The search understands your wording, not just the catalog's. It drops the filler a request is wrapped in ("enable", "turn on", "switch", "please", "how do I") and bridges the everyday word to the catalog's own, so "enable dictation" and "change my hotkey" both land on the right feature — measured 2026-10-12; before that both returned unrelated surfaces and missed the dictation and keybinding ones. A word that names a feature is never filler, so "get help" still finds the Get Help panel. A second wording is still worth asking when nothing fits.
  • A feature-recommendation catalog. The bundled library includes a generated feature-recommendations.md — released features grouped by user goal (built off the Feature Roadmap), each with a one-line pitch. So when you ask what to use, the agent recommends real, available features and never points you at something that hasn't shipped.
  • Your live state. The agent reads it with its own scoped token: GET /sessions, /projects, /settings, /settings?q=<term> and /settings/<key> on the local CLI control server (127.0.0.1:19519). The ?q= form is the setting-side search — it returns only the settings whose name contains the term, with their current values, so the agent can find the key behind a plain-English ask without pulling ~140 keys it cannot read in one clipped call. A secret key is stripped before the match runs, so searching for one by name returns nothing rather than confirming it exists. GET /inbox and /focus are navigation routes; an agent-initiated call to either never moves your screen on its own — a bare GET /inbox is a read-only no-op, never a way to read what is waiting on you (unless you have turned on "Let agents switch your view directly"). Its ?navigate=1 form is what the agent sends when you ask it to take you to the inbox, and still only offers a "Go there" toast. /state itself (accounts, integrations, the whole-app overview) is owner-only and answers 401, which it says rather than working around. Read budget is 60 reads/min per token.
  • Your past sessions — by name, not by content. GET /search/fts and /search/semantic are closed to its token by design: they run over every session's messages, and a scoped per-session credential must not be able to recover another session's content by search. So for "which session was about X?" it searches names with GET /sessions?q=<your words>&excludeSessionId=<its own session> — the q filter reaches every session, not just the newest page, and the exclude keeps the help chat out of its own answer (its name is your question, so it would otherwise match first) — and hands you a clickable omniscio://session/<id> link; a content search is pointed at the app's own search box, which runs with your authority. It never opens the database directly.
  • Project context. Read, Grep, Glob, Bash and WebFetch are available, so it can open files outside its working directory when relevant. Write and Edit are not — see No file writing, ever above.

What the agent can do

Changed 2026-10-18. The agent holds two credentials, both minted into its session at launch: the scoped read token it has always had, and a separate action credential (AMC_ACTION_TOKEN) that is the only thing the app accepts on a write. That is the owner's decision of 2026-10-12 — "Same as the app's other trusted helpers" — and it means Ask can do the small, ordinary things you ask for instead of only pointing at them. The narrow read token is not the one that makes changes: a settings patch sent with it waits on your own approval preference like any other agent's, so a token that leaks out of an agent's environment cannot change your configuration behind your back. Ask never holds the install-wide key, never reads a key file, and a refusal is answered honestly.

Changed 2026-10-19. The reach that grant describes now includes your scheduled jobs: the agent lists them on its read token, and enable/disable, edits, a manual run and a delete take its action credential. What the app reserves for you is untouched — a job awaiting your approval refuses to run, and approving or rejecting one is refused to every agent.

  • Changes an ordinary preference for you. "Turn on dark mode", "change the screenshot hotkey", "create an inbox rule that silences the nightly bot" — it finds the exact setting, applies it with the action credential, and reads the value back before saying it is done. Keybindings apply immediately; an inbox rule it creates lands pending until you approve it, which it says.

  • Changes every setting that the app lets an agent change. Most settings, including the load governors, Hardcore Mode, the credential pathway and the pipeline-arming levers, are applied with the action credential and read back. The control-plane toggles and the safety, Lab and feature settings on the always-card list come back as a card you answer yourself. The other exception on that road is the land data-safety standards, which the agent may make stricter and never weaker (403).

  • Asks you on a card for the settings the app holds for your own decision. The sign-in gate, the phone second factor, the network allow-list, trusted sheets and a weaker land data-safety standard come back to the agent as an approval card: nothing changes until you click Approve, and the agent tells you a card is waiting rather than saying it is done.

  • Hands you a jump to the few settings no agent may ask for. The paywall enforcement levers, the terms and consent records, every secret, the plugin-settings map and the PR Janitor pause answer 400 "not patchable via CLI", so nothing is ever queued for you to approve. The agent says "I can't change that one for you" and points at the setting to flip yourself.

  • Still hands off what only you may do. Some keys are refused to every agent credential and stay yours; it says "I can't change that one for you", names the setting, and offers a one-call jump (GET /settings/open?q=…) that either moves you there or shows a Go there button. It never describes that hand-off as a change it made.

  • Sees and changes your scheduled jobs. "What cron jobs do I have?" is answered from GET /cron/jobs on its read token, and "turn off my standup job", "run it now", "rename it" or "delete it" apply with the action credential at once. Moving or retiming a job you had already approved does not: a change to when it runs puts it back in your inbox for approval — what a schedule change on a live job has always done — and the agent says it is waiting on you rather than reporting it done. The same holds for a job you have not approved, and approving or rejecting one is refused to every agent credential.

  • Reads your live state. GET /sessions, /projects, /alerts/types, /cron/jobs, /settings and /settings/<key> all answer its read token, so "what needs my attention?" and "what is this set to?" come from the live app, not memory. GET /focus brings the app window to the front on your screen and returns no state. GET /inbox is not a read: it returns no items, so the agent takes a session id from GET /sessions instead. GET /ui/snapshot is how it sees what you are looking at.

  • Never stalls on its own control-server call. A single GET (or HEAD) to Omniscio's own local control server is approved automatically, and so is a single write that carries its action credential and an inline body — so an ordinary preference applies right away instead of waiting for a permission tap. A read may also end in a single | head -c N or | head -n N stage (how it clips a long answer) or a single 2>/dev/null discarding its own error output — neither can write. Everything else still asks — any other pipe, a second stage, a chain (;, &&), another host or an output file, a 2>/dev/null on a write, any write without the action credential — showing the Allow/Deny card in the chat itself, so nothing fails silently. A setting the app holds for your own decision still comes back 400 with nothing applied.

    One call per command (2026-10-20). A standing rule now tells the agent to issue each control-server read as a single curl and make a second call rather than chaining or piping into another program. Piping a reply into python3, jq, grep or sed is arbitrary code by definition, so it can never be auto-approved — such a request parks on a card. Measured before this change: 115 of 132 real requests (87%) parked, 22 of the first 64 on a pipe into python3 and 23 more on ;/&& chains.

  • Recommends features by goal. Ask "what should I use for X?" or "recommend a feature" and the agent matches your goal against the released-only recommendation catalog and suggests a few that fit — grounded in what's actually shipped, so it won't pitch an unreleased feature.

  • Finds and opens the exact control. GET /ui/snapshot finds the anchor and its label, and POST /ui/open / POST /ui/highlight accept the action credential — so it can take you to the panel and spotlight the control. If you haven't allowed agents to move your screen, it offers a Go there button instead.

  • Converts and downloads for you. POST /convert (for example PDF → Markdown or MP4 → MP3) and POST /download write a new file beside the original, and both take the action credential.

  • "Done" means it read the change back. For an artifact it publishes itself (POST /share/publish, or a report it assembles through POST /report-template/render) it re-reads the result and hands you the link; for a queued card it says plainly that it is waiting on you. It never ends a turn silently: if a call failed, was refused, or timed out, you still get a reply saying what it tried.

  • A success message from the app is not the same as the thing you asked for. A 200 or 201 only acknowledges the request, so the agent checks the actual result before saying "done": the setting shows your new value, the item is really in the list. A two-part request — a shortcut and what it opens, the microphone and its button — counts as done only when both are true, and something you can see or press is checked as that control itself, not the switch meant to reveal it.

  • It won't invent a feature. If the app's own documentation does not describe what you asked for, it says Omniscio cannot do that and offers the nearest real alternative, rather than claiming success — and a setting whose name sounds like your request is not treated as the feature itself.

  • A "no" changes nothing. When it cannot do something, that turn makes no change at all (no "helpful" substitute you did not ask for) and ends with one concrete thing you can do yourself.

  • Asks you for anything it is refused — on one approval card. (Changed 2026-10-29.) When its action credential is refused on a change — launching a session in one of your projects, starting a Night Shift plan, an integration write, a Team Chat message — the agent no longer declines. It sends the same request to POST /ask/requests with a one-line reason, and you get one approval card that names the action, shows the exact request and its contents, and says why. Approving it runs exactly that request, once, with your authority; nothing runs until you click, no setting or "always allow" can approve it for you, and the agent never sees what the action returned — only whether it ran, was declined or did not complete. (Changed 2026-11-09.) This is no longer Ask's alone: any agent session — a coding session, a crew member, the Simple Mode helper — can send a change it is refused to the same road with its own session key, and you get the same one card, with the same rules. The install-wide key never asks (it already acts as you). Each session may hold at most five of these cards open at once, so one busy agent never blocks the others, and all sessions together at most fifty. Cloud machines never raise them. (Fixed 2026-11-07.) The card's title names the action in plain words: a developer note such as ({ reason? }) in the action's description is left off. (Changed 2026-11-19.) The card reads as a sentence, not as the request it carries. The title names the thing it changes — for a crew switch, the crew's own name: Turn off the mission lead loop for the crew "PMT3" — with no HTTP verb, route or body shape anywhere in it. Under it come only the change's own fields, who asked (a clickable session name) and the note; a raw internal id is never printed. The exact request — the method, the route, the body and the asking session — is still on the same card, one click away under Show technical details, so what approving runs is always inspectable before you click. Unsnoozing a session never needs a card at all — Ask may unsnooze any session straight away. A background worker or a cloud session may unsnooze only itself, so a cross-session reach belongs to Ask (and to your own CLI token). (Fixed 2026-11-12.) An address that cannot be sent — a raw space where the path needs %20, as in /project/Journal Dev/new — is refused the moment it is asked for, with a note saying how to write it, so you are never shown a card for a request that could never run. And if a request never left, the card says it was not sent; "sent but no answer came back" is only for a request that really went out.

  • A session you approve starts as your own launch. (Fixed 2026-11-06.) Approving a card that starts a session counts as you starting it, so it never waits behind the low-memory hold that paces background agent work — before this fix such a session could sit on "starting" for as long as the computer stayed short of memory. And if any session is ever waiting to start that way, typing a message into it starts it at once.

  • What it still never asks for. Reads (they stay refused), anything that approves, rejects or answers something already waiting on you (other cards, devices, pairings, pipeline gates, scheduled jobs — those stay yours to decide in the app), anything that carries or creates a secret (you enter those yourself), agent-fleet safety actions, starting another help agent, and changes it already makes directly. A request or reason that looks like it carries a key is refused before any card is made.

  • No process spawns on its own initiative — a standing instruction, not a hard block. The agent is told never to call /project/.../new unprompted (that would spawn a real Claude process and cost money), and its session runs with Write and Edit disallowed. Settings → CLI Control → "Require approval for AI session spawn" (requireApprovalForAiSessionSpawn) ships off, and the spawn router then launches directly — the only unconditioned backstop is the outstanding-spawn backlog cap. Turn it on to route every AI-initiated spawn through an inbox approval row first. With "Allow agent-token spawn" off, the agent's own launch is refused and comes to you as an approval card instead (above).

  • Hands off real build work — on your explicit ask. Ask Omniscio is the in-app helper: no access to the Omniscio source code and no file writes, so it won't try to build or change code itself (or hunt for a "repo" it doesn't have). A change to Omniscio itself becomes a report instead: it files what you wanted with POST /feedback, which is what reaches whoever builds the app — your machine does not hold the app's source. Work in your own code is the case that hands off: when you ask it to actually build, fix, or change something there — or say "spawn a session to do X" — it offers to spawn a separate dev session in that project of yours (which has the code and the full dev pipeline). Two things gate that hand-off: with Settings → CLI Control → "Allow agent-token spawn" off, the launch comes to you as one approval card, and it only asks when you clearly asked — offering first when the request is ambiguous. Because that spends money, it never spawns silently.

Question log + outcome rate (owner review)

Every time a help conversation starts, Omniscio records the opening question to a small local table, ask_amc_questions, so the owner can review what people get stuck on — and, since T-6, how often Ask actually does the thing. A row captures the question text, which surface asked it (ask_amc here, or ask_page for Ask about this page), a link to the session (open it to read the answer), an attachment flag, a timestamp, and the conversation's outcome. One row per conversation; follow-up turns aren't logged separately.

  • Every entry point records — including the header button, Ctrl+/ and the sidebar. Those three open the Ask panel, which starts with a blank session and receives your question only when you send it. So there are two writers on purpose: the spawn-time one for a conversation that arrives with its question (the Quick Launch "Ask Omniscio" tab), and a send-time one for the blank-then-type path. Both call the same function, idempotent per conversation, so a request is recorded exactly once either way. (Before this, the three panel entry points recorded nothing.)
  • The outcome, settled when the turn ends. Exactly one of five: DONE (it happened), HONEST_DECLINE (an honest "I can't", with a next step), FAILED (it tried and didn't succeed, or the turn errored), SILENT (no reply at all — it ended mid-tool-call or never answered), STOPPED (you pressed Stop before it finished). It is settled once, at the first turn that concludes — a turn ending in a clarifying question leaves it open — and a Stop settles it directly, since a stopped turn concludes nowhere else. A request that has not concluded yet is reported separately as pending, never counted as an outcome. A STOPPED request counts as settled but as neither answered nor a failure: stopping is your call, not the agent's.
  • How HONEST_DECLINE is known. "An honest I can't" is a judgement the app can't make from its own state, so the agent marks it: when it genuinely can't help, it ends with [[OMNISCIO_DECLINED]] on its own line. That token is stripped before you ever see it, and it is the only way a refusal is counted as one instead of as a success.
  • Where to read the rate. GET /ask-amc/outcomes (optional ?days=N, default 30) returns every outcome count, pending, the total and the rates — all computed by the backend. On a developer build, the Ask panel's start screen shows the same numbers as one line under the suggested questions, once at least one request has been recorded; an installed copy never shows that line: the success rate is a product-quality metric for the team, not something a customer acts on.
  • Local table + anonymized cloud view. The full row (with the session link) stays in the local SQLite DB — there is no LOCAL in-app viewer; it's read back by querying the DB / listAskAmcQuestions() (queries-ask-amc-questions.ts). A telemetry-gated fleet tail also ships an anonymized, scrubbed, length-capped copy of the question (no session link, keyed only on a random install id) to the owner's cloud, where the admin console's "Search & Questions" tab shows what people ask across all installs. It rides the same Error-Reporting (telemetryEnabled) consent as every other fleet event and auto-deletes after 180 days. (The outcome does not ship to the cloud yet — that needs the cloud ingest to accept the field first.)
  • Bare question, not screen context. "Ask about this page" logs only the question you typed, never the captured on-screen context (which rides in the model prompt, not the log).
  • Fail-safe. Logging is best-effort on every live path: if it errors, the help agent still answers and your message still sends (the "never breaks" guarantee). The writers are ask-amc-outcome-recorder.ts, called from the spawn chokepoint in session-create.ts and the send path in session-service.ts; the outcome is settled from the turn-end path in ndjson-event-handlers.ts. Full invariants: .claude/memory/contracts/ask-amc-questions-log-contract.md, .claude/memory/contracts/ask-amc-outcome-contract.md.

No final-message marker

An Ask Omniscio answer never carries the [[OMNISCIO_FINAL]] marker, and the helper is never taught it. That marker is an agent-session protocol — it tells the app where an agent's working notes end and its real answer begins — and an Ask reply IS the result, so there is nothing to fold and a marker that slipped into an answer would simply be a stray token a reader (or a copied, exported or mobile view) sees. Two halves keep it out:

  • The instruction is never delivered. The session-shape fragments that do not apply to the answer-in-a-box helpers are dropped by ASK_HELPER_DROPPED_FRAGMENTS in engine-prompt-bundle.ts, the same mechanism that already withholds Plain Speak, the waiting sentence and the woken no-op from them. An external engine's per-turn reminder resolves the same exclusion from the session's own project.
  • The app never derives one either. The turn seal can infer a final-answer boundary from the CLI's own result text and write a synthetic marker at it; for these helpers that is skipped and a marker the model wrote is stripped, so the stored reply is pure answer (streaming-finalizer.ts).

"Ask about this page" follows the same rule.

No Plain Speak overlay

An Ask Omniscio chat shows the answer, not a plain-speak card restating it. A second copy behind a ⇄ toggle is noise, so the project carries the per-session overlay opt-out — stamped at session birth, exactly as Session Search does, and read at every spawn. Same rule, same single home: OVERLAY_SUPPRESSED_VIRTUAL_PROJECT_PATHS in virtual-project-ids.ts — see session-search.md for the mechanism. This concerns the transcript overlay only; the on-screen spotlight and guided tours above are a different feature and unaffected.

Privacy model

  • Settings whitelist redaction. The /state endpoint exposes settings through a closed whitelist; any AppSettings field not on the list is dropped. A test asserts that adding a new field forces a deliberate whitelist opt-in, so secrets cannot leak by default.
  • Inbox is metadata-only. /state returns sender, channel, timestamp, status, and a 100-character preview — never the full message body. Ask Omniscio does not browse your message content, and since 2026-10-12 it cannot search session content at all: the /search/* routes are refused to its scoped token by design.
  • Bearer tokens are private. The agent authenticates against the local server with its own two credentials — the scoped read token and the action credential — and is told never to echo either in chat output, or to read a key file, the secrets vault or a config to find a stronger one.
  • No MemPalace cross-pollination. Even when you have MemPalace turned on globally, it is NOT attached to Ask Omniscio sessions in v1, so help-agent chats can't accidentally read or write your project memories.
  • Where your questions go. Normally Ask Omniscio uses your own Claude credentials, so questions go to your own account/provider — exactly like every other session. If you have none and it falls back to the built-in company model, a typed question is sent to DeepSeek V4.1 Flash through Omniscio's company gateway, and that includes whatever log lines, file excerpts or command output the helper reads while it is diagnosing your problem. A question with a screenshot or PDF attached goes to Anthropic's Claude Haiku instead (and a typed question is re-run on Haiku if the DeepSeek lane fails). So on that fallback lane your question, and anything the helper opens while working on it, leaves this computer to a third-party AI provider. Everything else above (whitelist redaction, metadata-only inbox) still applies either way.

v1 limitations

  • No cross-chat memory. Each Ask Omniscio chat starts blank. If you want a fact remembered between chats today, you'd file it via MemPalace from a regular session.
  • No starter prompts. No auto-introduction or seeded chat. You decide when to start one.
  • No SSH-remote spawn. Ask Omniscio sessions always run locally; the spawn never forwards to an SSH-remote host.

How it works

The toggle askAmcEnabled lives in types.ts with the matching Zod field in ipc-schemas.ts (updateSettingsSchema); DEFAULT_SETTINGS.askAmcEnabled is true. The header button is the static ask-amc toolbar item in toolbar-catalog.ts — that exact id is load-bearing, because the header DERIVES an integration:<id> quick-access button for every built-in sidebar row and only an exactly-matching static id suppresses the duplicate. It is gated by visibleWhen: askAmcEnabled !== false and reaches existing users through its own one-shot pin migration (askOmniscioToolbarPinBackfilled), since a stored pinned-list never picks up a new default. All three doors run the one shared opener open-ask-omniscio.ts, so the gate and the destination cannot drift. The Ctrl+/ binding is declared in ask-amc.keybindings.ts. The sidebar entry uses sentinel virtual project ID __ask_amc__ from virtual-project-ids.ts, resolved to <userData>/ask-amc/ by claude-project.ts. The project row is created by ensureAskAmcProject() from two call sites: at app startup in index.ts when the flag is on (covers fresh installs and configs that pre-date the field), and from the settings-update handler on a toggle-on transition (covers users who turned it off and back on). The seeder is idempotent — second and later calls are no-ops on an already-active row, and undelete a soft-deleted one. Turning the toggle off never deletes the row (the sidebar filter hides it), and a throwing seeder never blocks the save: the toggle is persisted first and the handler still reports success. Where the row is drawn does not depend on its stored display_order, pin flag or divider: computeSidebarZones (side-nav-zones.ts) always places Ask Omniscio (when askAmcEnabled) in the fixed top zone, after Inbox and Claude and before the user's pins. A renderer-side selector in project-visibility.ts filters __ask_amc__ out of the visible-projects list when !settings.askAmcEnabled, subscribed to SETTINGS_CHANGED push so flag flips take effect without a reload. The /state endpoint is implemented in cli-server.ts backed by a unified-inbox composer in state-redaction.ts that calls the seven per-source backend queries (sessions, SMS, Telegram, digest, cron approvals, automation approvals, recipe approvals) and merges by timestamp. Spawn integration lives in process-manager.ts: when the session's project resolves to the __ask_amc__ sentinel, a process-level mutex serializes the spawn, ask-amc-bootstrap.ts atomically refreshes the workdir (write to <userData>/ask-amc.bootstrap-tmp/ then rename) from resources/llm-library/ and resources/ask-amc-claude.md, MemPalace MCP is force-disabled, and --append-system-prompt carries a 5-line shim that tells the agent to fail loudly if the workdir CLAUDE.md was not auto-loaded. If bootstrap throws, the spawn aborts and surfaces a user-facing toast — no silent agent-without-context.

Engine routing (all three help agents). Ask Omniscio, Ask-about-this-page and the Simple Mode concierge follow the normal engine choice (pickProviderForNewSession). The help-agent list is ONE leaf, help-agent-kind.ts. When the chosen engine is not usable — readiness fails, the per-engine login/key check (providerHasCredential) fails, or it is Devin — resolveHelpAgentLaunchProvider() (help-agent-launch-provider.ts) settles on Claude at both launch doors, drops the inherited model/thinking level, and writes one notable-system note. On a non-Claude engine the help workdir is bootstrapped in the shared launch door, each persona is written to CLAUDE.md/AGENTS.md/GEMINI.md, the engine prompt bundle carries the Ask shim (+ a read-only rule) or the concierge's ask-first briefing, Omniscio hands no MCP servers, and no revival road (startup, sweeper, crash, suspended) relaunches a help chat. An Ask session on a ready Claude-compatible vendor counts as the user's own AI.

Company-model routing. askAmcUseCompanyModel (default true, agent-tools-settings.ts) gates a pure decision function resolveAskAmcModelPlan() (ask-amc-model-plan.ts) that the spawn path (spawn-cluster-manager.ts) consults before injecting credentials. The user's own credentials come FIRST: the spawn passes userHasOwnCredentials, derived from the session's auth pathway by askAmcHasOwnCredential() (resolveSpawnAuthMode() — managed/ownLogin count when an account row exists; passthrough and apiKeyOnly ask the shared hasNativeClaudeCredential(), so passthrough counts only when a Claude login is really present — hasClaudeCliLoginAsync() in cli-account-detector.ts: the credentials file, a renewable expired login, or on macOS the "Claude Code-credentials" Keychain item, failing open — and apiKeyOnly counts when the isolated slot holds a key); when true the plan returns user-credentials-first and the spawn credentials exactly like any other native session. Only when it is false does the plan route to the company Claude Haiku key (MODEL_HAIKU_LATEST, from getAskAmcFallbackApiKey() in default-credentials.ts), overriding --model and appending the per-session --max-budget-usd cap; with no company key it falls through to the Layer-5 gateway fallback (so never-breaks holds); with the setting off, Layer 5 stands down too and a credential-less user gets the standard "sign in" refusal. The plan takes the help-agent kind (helpAgent: ask-amc | ask-page | concierge), so all three helpers share the one ladder and the one durable daily cap (ask_amc_company_spawn_daily). Layer 5 obeys the cap and the paid-tier lever, claims its slot last, runs only for a Claude session, and applies helpRescueRestrictions(helpAgent, argvModel) (Write/Edit off + the per-session cap + the lane's own model whenever the --model on argv is not one the gateway's allow-list publishes — the rescue runs AFTER the plan reached argv and may fund a spawn whose plan came from the user's own lane, so without that substitution a rescued chat would carry an id the gateway refuses and 403 every turn) to argv. That per-session cap is one of two ceilings on this lane: the ask-amc-rescue feature also declares lifetimeCapUsd: 0.25 in company-lane.ts, which the gateway turns into a per-uid ceiling that never resets — the owner's "$.25 total ever". One bounds the conversation, the other bounds the person; with no rescue, ask-page and the concierge stop with the helpAgent empty-credential refusal. Write,Edit are added to --disallowedTools on every path, company or not — the restriction describes the agent, not the funding source (Bash stays — Ask Omniscio needs it to reach the local control server). Full invariants: .claude/memory/contracts/ask-amc-contract.md → "Company cheap model (the FALLBACK — the user's own credentials come FIRST)".

Disabling the baked-key spend (operator kill switch). Setting AMC_DISABLE_ASK_AMC_FALLBACK=1 stops Omniscio from ever spending on the bundled Anthropic key at runtime — no new build needed. The company-model routing, the automation-helper company key, and the Layer-5 bulletproof fallback all read one getter (getAskAmcFallbackApiKey() in default-credentials.ts), so one flag neutralizes all of them: each degrades to the user's own credentials, or the standard refuse-spawn toast when the user has none. It exists so a leaked or abused baked key can be shut off instantly.

  • first-day-welcome-session.md — the "Welcome to Omniscio" chat a brand-new user starts from the "Ready for your 5-minute interview?" inbox card; it is an Ask Omniscio chat acting as a first-day guide
  • cli-control.md — the local HTTP server the agent reads with its scoped token (/sessions, /settings and its other reads; /state is owner-only)
  • cli-pending-actions.md — how approval-gated mutations land in your inbox
  • create-cron-job-with-ai.md — sister flow for external AIs using the omniscio-control skill
  • mempalace-memory.md — opt-in cross-session memory (separate feature, not attached here)
  • documentation-updates.md — how the built-in documentation this agent answers from is kept current with the published docs site

Last verified 2026-10-29