Omniscio

Instant new session on mobile (create-on-send)

On a phone, tapping New Session opens a real new-session screen instantly — the same setup controls you get on desktop, with a composer and no spinner — and the session is only actually created when you send your first message. On by default; covers what you see and why it cannot leave a ghost session behind.

On this page

What it is

What it does

On a phone, tapping New Session now opens a real new-session screen instantly — "Start a new session" with the model / thinking / MCP pickers (the same start-config controls you get on desktop) and a composer. No spinner, no "Starting session…", nothing sent to your computer: it's pure interface — no session is created yet, no Claude process starts, nothing crosses the network. The real session is born the moment you send your first message — and sending is fire-and-forget: you're instantly returned to whatever you were doing while the session builds invisibly in the background. It doesn't matter if your computer takes a minute (or an hour) to finish creating it — you never wait and never watch; the session just appears in your list when it's ready.

Because tapping is just paint, it's effectively free: you can fire off as many new sessions as you like, one after another, and every one is instant. There's no hidden session being prepared behind the scenes to "keep up with" — so a fast burst of taps can never outrun it.

The new-session screen's code is not part of the app's first download, so the app opens faster. The phone fetches it quietly in the background a moment after the app has drawn its first screen, so by the time you tap New Session it is already there: the screen opens instantly and the keyboard comes up. If you tap before that background fetch has finished, the first tap shows a short loading spinner instead.

This replaces the older approach on mobile, where Omniscio quietly pre-created a real blank session for every tap and tried to keep one ready ahead of you. That worked when a prepared blank happened to be ready, but on a phone — where preparing one has to travel over the network — a quick second tap, a tap from the Inbox, or a tap in a non-Claude project could miss and fall back to a several-second spawn. Create-on-send removes that whole class of "sometimes slow." (Desktop is unchanged — Ctrl+T keeps its own pre-warm fast path; see instant-new-session.md.)

Where to find it

On a phone: the New Session button. The switch that turns the behavior off is Settings → Performance → Instant new session (mobile).

The setup rail has its own switch: Settings → In development → Mobile setup rail. Turn it off to restore the previous "Session setup" card under the large centred orb.

How it behaves

What you see

  • Every New Session is instant — the new-session screen appears the moment you tap, however many you create in a row.
  • Opens ready to type — the message box is focused the moment the screen appears, so the phone keyboard comes straight up. (A draft the app restores on its own when it reopens has no tap behind it, so it is focused but the keyboard waits for you — phone browsers only raise the keyboard after a tap.)
  • Everything on one screen, above the keyboard — a single setup block sits directly above the message box: one line with a small Omniscio orb beside a rotating headline ("What are we building?", "What's on the workbench?" and the other shared lines), then every setup choice as a 2-column grid of labeled tiles — Preset, harness, provider, model, thinking, run location and MCP servers — each tile showing its name above its current value. All of them stay visible with the keyboard up. Nothing hides behind an arrow, and the block never grows past half the visible screen, so the message box stays in view with the keyboard up. The Model chip always names your real default engine's model — a DeepSeek default shows a DeepSeek model, not Claude's. It's the exact same session launcher the desktop new-session screen uses: on a phone the launcher itself renders this grid (preset tile, tile grid, set-as-default hints), so every screen that picks what runs a session shows the same phone picker (no mobile-specific copy). Pick your setup before you send; whatever you pick is applied to the session that gets created.
  • You can set your defaults right here, like desktop — pick a model, engine, or thinking level that isn't your usual one and a "Make it my default" option appears below the pickers (only this hub, all sessions on that engine, or everywhere) — so you can promote a new favorite to your default for new sessions without ever opening Settings. The option only appears when your pick actually differs from your current default, so it never nags.
  • A photo or file on its own is enough — attach a photo, a screenshot or a document (a PDF, a Word file, a text file…) and Send lights up even with nothing typed, just like in a running session. The session starts with it as the first message (the chat shows just the attachment), and the agent is told to take a look at it — the same way desktop Quick Launch starts a session from an attachment alone.
  • Send is instant and invisible — hitting Send returns you to exactly where you were (the session you were reading, or whatever screen you launched from) immediately and builds the session entirely in the background, however long that takes on your computer. You keep working on your phone; the new row appears in your list when it's ready. No spinner, no waiting, no watching.
  • It works everywhere on mobile — the footer New Session button, the inbox-group +, and the breadcrumb +, and in non-Claude projects (Gemini, Codex, Cursor, …) too, which the old pre-warm skipped.
  • An un-sent screen isn't a session yet. A screen you open but never send doesn't appear in your session list — by design, nothing exists until you send. Send your first message and it becomes a normal listed session with that message already delivered.
  • A page refresh doesn't lose it. If the page reloads while you're writing — after an update, or when your phone closes the browser tab in the background — you land back on the same new-session screen with your text, photos, files and setup. Leaving the screen yourself still throws it away, and so does closing the tab or the app.
  • A slow desktop is not a failure. If your computer is busy and takes minutes to build the session, or your phone's connection blinks mid-send, the app quietly checks back on the same send until the session exists — it never starts a second one. Only after 8 minutes with no answer does it stop and tell you it couldn't confirm the session started, so you can check your sessions before sending again.
  • Your typed text is safe. Your message, photos, files and setup are kept on your phone from the moment you tap Send until the session is confirmed — even if the page reloads. If starting the session really fails (you're at the 200-per-project cap, the engine isn't set up), a notice stays on screen with the reason, Open your message (reopens the new-session box with everything filled back in) and Retry (sends it again in the background). It never yanks you back into the composer on its own.

Turning it off

On by default. Turn it off in Settings → Performance → "Instant new session (mobile)" to go back to the old behavior (Omniscio prepares the session as soon as you tap). There's also a developer kill switch, AMC_DISABLE_MOBILE_CREATE_ON_SEND=1, that force-disables it regardless of the setting. Either gate off reverts mobile New Session to the pre-warm/"Starting session…" path; desktop is never affected by this flag.

Why it's safe (the "no ghost session" rule)

An earlier attempt at instant sessions once caused data loss by showing a fake session that became "real" later — a placeholder that leaked into the real session list and got confused with a genuine row. Create-on-send is built so that can't happen: the empty box is a client-only draft that never enters your real session list, never your history cache, and can never be archived or deleted. It's a separate thing entirely — there is no session object to confuse. The real session appears only when the backend creates it on send. A guard test (mobile-draft-no-placeholder-in-sessions.test.ts) permanently locks that the draft can never reach the real session list, so this is actually safer than the pre-warm it replaces (whose pre-created blanks were the source of the old bug).

  • start-a-new-session.md — the full new-session flow (projects, launch targets, picking a tool/model).
  • instant-new-session.md — the desktop Ctrl+T pre-warm fast path (still in use on desktop).
  • keep-alive-pool-contract.md — the behavior contract + the load-bearing "no placeholder in the session list" invariant.

Last verified 2026-10-31