Inside a live session — what the LivePair agent actually does

It watches before you ask

The moment a session starts, the agent begins observing — your shared screen or the camera watching your workspace on an Android rig, plus the conversation audio. It doesn't wait for a prompt. It builds a running model of what you're doing: the task, the artifact on screen, the people in the conversation, and where things seem to be heading.

There is no 'explain your context first' step — your screen, audio, and room stream to the agent continuously, so the context is the session itself.

It drives the viewer — you don't

The second screen isn't a dumb mirror. As the session moves, the agent navigates the viewer itself: it follows the file you're editing, scrolls to the relevant code, brings up the artifact being discussed, and pins what matters — a real Pad action, driven by the agent's own view controls. When you jump from a test failure to the implementation, the display is already there — you never touch it.

If a teammate joins the viewer link, they get a read-only seat with a derived access token — they can watch the agent's current view but can't drive it or see your controls. The link can be shared without exposing your session key.

It understands conversation, not just commands

The agent listens to the whole room, not a push-to-talk button. It distinguishes work dialogue — you and a colleague arguing about an approach — from requests actually directed at it. Talk over a problem with someone and it follows along silently; say 'LivePair, pull up the schema' and it acts.

Because it tracks the conversation as a timeline, it can answer 'what did we decide about the retry logic ten minutes ago?' without you re-explaining anything.

It detects the mode of work itself

You pick the mode — work sessions or mic-only Duo — but inside a work session the agent infers the kind of work from evidence: screen content, speech patterns, tools on screen. Heads-down engineering with an IDE and stack traces reads differently from a slide deck with a room full of questions, which reads differently from a support call.

When the mode shifts — a debugging session turns into an impromptu demo — the agent's posture shifts with it: what it watches for, what it surfaces, when it speaks. You never tell it 'now we're presenting.'

It reacts to vague work — and flags risky calls

You don't need a well-formed question. Even when the task is vague — half an idea on screen, a design you're still circling — the agent follows along and reacts to what's actually happening, not to a clean prompt.

When something on screen turns risky — a command about to drop data, a number that contradicts what was said, a change that breaks the build — it speaks up over audio and pins the flag in the session context, so the consequences of that call keep being tracked instead of forgotten the moment it scrolls away.

It speaks up before you have to ask

The point of a live model is proactive help: a test that just broke, a number on screen that contradicts what was said earlier, a decision about to become hard to undo. The agent surfaces these while there's still time to act — not in a summary email after the damage.

Just as important: it knows how to stay quiet. If nothing needs surfacing, it produces nothing. No filler, no 'just checking in' — silence is a valid output.

What a session costs

Live sessions draw a prepaid minute pool — packs of 30–300 minutes, from $3/hour (the rate tracks provider cost, never below); Duo is $10 for 30 minutes. Work sessions need the 60-minute tier and a desktop browser or Android host — iOS Safari runs camera-only sessions in beta; Duo is mic-only and runs on any phone. Minutes never expire and stay separate from agent chat credits. A first purchase includes a free 10-minute session. Details: pricing.