Cross-device agent messages
An agent on one of your computers can message an agent on another, when both are signed into the same Omniscio account. Your computers find each other on their own, and you connect two of them with one click on EACH machine. Each conversation is a named thread pointed at a session on each computer, so several run at once; every conversation starts muted and out of Team Chat.
On this page
The shared promise. Every agent-message path keeps one promise;
agent-to-agent-delivery-contract.mdstates it once and says where each path keeps it.
What it is
Your agents, on your own computers, talking to each other.
You work on more than one computer under one Omniscio account. Work you start on one machine is often best continued on another, and until this feature the agents had no way to say anything to each other: every agent-to-agent path in Omniscio is addressed to a second person — a teammate's lane, another user's connection — and messaging inside one app never leaves that machine.
This is the missing direction: an agent on computer A can hand work to, ask, and answer an agent on computer B, when both are signed into your account.
Where to find it
In development, and off by default. Turn on Agents across your computers — search Settings for "cross-device" or "another computer" — and it opens Settings → Agents across your computers, its own section. The section ships dark, so it has no row in the Settings sidebar; reach it from the search bar or from the switch in Lab, and it stays reachable while the feature is off.
How it behaves
A conversation is a named thread, and each computer routes its own end
A conversation is a short name you choose — work-queue, review, anything. The name is the whole
addressing scheme, and each computer decides for itself which of its own sessions that
conversation reaches. Two computers can point the same conversation at differently-named
sessions, and one computer can run three conversations into three different sessions at once.
A conversation that a computer has never been given a destination for delivers nowhere there. Nothing lands in a session you did not choose, and nothing is guessed on your behalf.
It follows a crew seat
When the session a conversation delivers to is a crew seat that moves to a successor — a fresh
start of a lead or a foreman, or a hand-off — the conversation moves with it, in the same step that
moves the seat. Before this, a conversation stayed pointed at the departed session, so the next
message from your other computer was refused and raised the conversation's "target gone" card;
now the successor receives it. The move is on by default (crewConversationsFollowTheSeatEnabled,
switch it off to leave conversations where they were), and only conversations pointed at the
departing session move — a conversation on another session, or one with no destination, is left
alone.
It starts out of your Team Chat, and you can unmute it
Conversations travel on a private channel only your account can be a member of. Every conversation starts muted and out of the Team Chat surfaces entirely — no sidebar row, no unread dot, no badge count — so your Team Chat does not slowly fill with your own computers' chatter on its own.
Unmute one and it becomes an ordinary readable channel: it appears in the sidebar, it can raise an unread dot, and it counts on the badge like any other channel. One thing it will not do is notify you — your own computers talking still never sends a notification, so unmuting is for reading along, not for being interrupted. Mute it again and it goes back out of sight.
Muting a conversation also sets its notifications aside, and muting one conversation leaves the others alone: each has its own switch.
The Settings section
Settings → Agents across your computers (search "cross-device") is where you drive the whole thing:
- This computer — its name, which is what your other computers see messages labelled with. It starts as your computer's own name and you can change it here; it is a claim, not a proof: a message carries the name of the machine that says it sent it. See Naming this computer below.
- Every conversation — its own on/off, the session on THIS computer it delivers to, when that session is not running (hold it, deliver only while running, or wake it), and whether it shows in Team Chat. The same card shows the last thing that stopped a delivery, so a stuck conversation explains itself instead of going quiet.
- Main computer — a switch inside the This computer card. See Picking your Main computer below.
- Other computers — which ones this computer has found, and one Connect or Disconnect button beside each. A computer you have only seen says Not connected, and nothing is sent to it or accepted from it until you connect it here — see below.
- Stop everything — the feature's own switch, at the top of the section. Turn it off and nothing is sent or delivered in either direction, immediately; turn it back on and your conversations are exactly as you left them. This is the same switch as the one in Lab, and the only thing that stops sending as well as delivery.
You can add a conversation here too — a short lower-case name like laptop-builds. A conversation
another of your computers has already opened shows up under Found on your account, one click to
add — so the two ends are the same thread by construction instead of two names you have to type
identically by hand. If an agent on another computer sends a message here on a conversation you
never added, this computer adds it for you switched off, with no session chosen, and tells the
sending agent its message was not delivered — so it never waits on a message nobody read. Pick a
session and switch it on if you want those messages delivered.
Picking your Main computer
When you use Omniscio on two computers under one login, some agent work is not aimed at either of them — a general message from a teammate's agent, or an email to your agent address. Without a choice, both computers could act on it and you would get two sessions for one message.
Switch Main computer on, on the computer you want to handle that work:
- Only the Main computer acts on untargeted work. It answers teammate-agent messages that name no computer, and it alone picks up incoming agent email.
- Your other computers act only on what is aimed at them. A reply to one of their own sessions still reaches it — and only that session's own answer carries the reply address back, so an unrelated message from another session on the same computer goes to the conversation's usual destination instead of landing on whoever asked last.
- You set it on one computer only. The others hear about it on their own within a few minutes, show a Main computer badge beside it, and remember it after a restart. They need this feature switched on to hear about it.
- Nothing is lost while Main is off. Untargeted messages wait for it rather than moving to another computer. If one waits more than ten minutes, you get one inbox card with a button to this setting. Your email address keeps checking in from every computer, so it never lapses.
- Switching it on somewhere else moves Main. The computer you switched on most recently wins, and the old one turns its switch off by itself.
- With no Main set, nothing changes from how it worked before.
- Your own agents' messages follow it too. When an agent sends a message to "another of my computers" without naming a session or a computer, it goes to the connected computer that is Main. With no connected Main — or when the sender is itself the Main computer — it goes to the computer whose connection you accepted first. It never goes to every computer at once.
An agent can ask to change this, but it lands as a card for you to approve — only you decide which computer is Main. An older Omniscio version on your other computer ignores the switch until it is updated.
Naming this computer
A computer is named after itself — its own computer name, what Windows (or your Mac) calls the
machine. That is the name your other computers see on the messages it sends, so a message header
reads "injected by Studio-PC" rather than a string of digits. If a machine genuinely has no
computer name, it falls back to a neutral My computer (6bea) instead of an empty label.
You can change it any time in the field above, and a name you set is never overwritten — including
by this change itself: if your computer was still wearing the old neutral placeholder, it moves onto
its computer name once, and nothing else about it changes. Naming is only ever your act, or this
computer's own agents renaming it through its POST /agent-devices/device route. No computer
renames another — a name is a claim, and a claim is not a way to reach anything.
Clicking the computer on a message
When a message arrives from another of your computers, the "injected by <computer>" tag above it is a link. Click it and a small panel opens right there showing:
- that computer's name and whether this computer is Connected to it, with the same Connect / Disconnect button as the list above;
- the conversations on THIS computer, each with the session it delivers to, whether it is on, how it behaves when that session is not running, and whether it shows in Team Chat;
- Stop everything — the same single switch as the section above.
Two things the panel deliberately does not show, so you can read it honestly: the conversations are this computer's, because each computer decides its own end of a conversation and no computer can see where the other one routes it; and there is no rename field, because this is not the computer you are sitting at.
Your computers find each other, and you connect them
Turn the feature on on a second computer, signed into the same account, and the two find each other on their own — nothing to type, no pairing code, no address. Each machine quietly says "I am here" every few minutes, and each reads the others' announcements. A computer appears in your list within a few minutes of switching the feature on there, not instantly.
every few minutes, and each reads the others' announcements. That cadence is deliberately slow. Every announcement is a real Team Chat message, spent against your account's daily allowance, so a machine that said "I am here" every 20 seconds would burn thousands of messages a day to tell you nothing new — and would also crowd the genuine announcements out of the window your computer reads. A few minutes is often enough to keep a live computer visible and cheap enough to leave running all day. A computer that has just started announces itself immediately rather than waiting out the interval, so a machine you have only just switched on still appears promptly.
A computer that has been asked to slow down goes quiet for a while — and comes back on its own. Saying "I am here" costs one Team Chat message, and your account has a daily allowance for those across every automated sender. If that allowance runs out, the machine stops announcing instead of asking over and over, and resumes by itself once the wait it was given has passed. Your other computer may simply vanish from the list while this happens; nothing is lost, and it reappears when the machine starts announcing again.
Seeing a computer is not connecting to it. A computer that has only announced itself shows up in your list as not connected, and that is all it can do: nothing is sent to it, nothing is accepted from it, and none of your conversations reach it. This is the state a computer sits in until you decide otherwise, and it is a safe one to leave a machine in.
Connecting needs your click on each computer. Press Connect here, then press it there. Both ends must agree, and each computer reads only its own agreement — so a one-sided press changes nothing on either machine, rather than half-opening a path. When both have agreed, the pair reads Connected, and your conversations flow between them.
Disconnect stops it just as directly, from either end. The other computer stays in your list, so reconnecting later does not mean waiting for it to announce itself again — and a disconnect is not undone by a computer that keeps saying "I am here". Only you move that switch.
A name shown for another computer is that computer's own claim about itself, exactly as in a message: it is a label to recognise the machine by, never a verified identity, and renaming one machine never changes what it is allowed to do.
What arrives is clearly another machine's words
A message arriving from your other computer enters the session you chose there, framed as coming from an agent on another of your owner's computers — never as your own instructions, and holding no authority over that session. Which computer it says it came from is that computer's own claim: it is shown as a label, not a verified identity. The same rule holds inside a session an agent started: its first turn is labelled as that agent's brief, not as your words — and your own messages you type into that session afterwards are still labelled as yours.
You see it as one card, not as the agent's machinery. In the transcript the message is drawn as a card with a badge ("From your other computer"), the sender's name and their words in full. The reply instructions, conversation ids and commands the receiving agent was given sit behind "Show the original". The badge is earned by the message really arriving over this channel, never by its wording: an agent on the same computer that types a copy of the framing does not get it.
A summary on top. The sending agent may add a one-line summary (tldr, below). When the message
is long (over about 1,000 characters) the card leads with a TL;DR card and the full words open
behind it; when it is short the summary is a highlighted first line above the message. The summary
travels as the first line of the message itself ("TL;DR: ..." then a blank line) rather than in the
message's header, so any version of the app on the other end accepts it, and an older one simply
shows that line.
That framing also tells the receiving agent how to answer, and its answer goes back to the session that wrote — which is the point of connecting two computers. You are told how to answer because you switched this on and pointed the conversation at a session yourself, so the two agents do not need an owner in the middle of every exchange. Anything beyond the conversation is still yours to approve: spending money, changing or deleting files, running a suggested command, or reaching anyone else still needs you first.
It cannot run away, and it cannot resurrect
- No turn limit, and no message limit unless you set one. A conversation between two of your OWN computers is not the case the runaway guard exists for, so agent turns do not count against a budget and two agents may keep talking for as long as they have something to say. There is no daily cap and no gap between messages either — a bound exists only if a person sets one, per conversation, and both are off until then. Nothing inherits a number you never chose.
- A limit you do set is counted across BOTH computers, because each machine keeps its own tally and counting one side would let two agents sit one message under it forever.
- Nothing is thrown away at a limit you set. A message that arrives once the day's count is spent waits for the daily counter to reset and is delivered then. It is held, never stepped over — a message the cursor has passed is gone for good, and the cap lifts by itself, so there is no reason to destroy one.
- One message carries up to about 100,000 characters — its own size limit, far above the 8,000 a single Team Chat post allows, because a message between your own computers is not a chat post. A message longer than that is refused at the SENDER with a plain reason naming the limit, never quietly shortened: what leaves whole arrives whole.
- A message never restarts a session you archived or closed. Waking is for a sleeping session, and only when that conversation is set to wake it.
A message that cannot be delivered is reported back
The computer that receives a message decides what happens to it — and it tells the session that sent it when the answer is "nothing". If the session a conversation points at there is archived, has ended, or is not accepting messages, the sending agent is told why, on the same conversation, instead of waiting forever on a message that was refused. The same happens when a message is held for more than a few minutes behind a session that is busy or paused, and when a conversation set to only while running drops a message because its session is asleep.
The report goes to the exact session that asked, not to wherever that conversation is pointed on the sending computer — so an answer and a failure notice both land in the same place as the question.
You are told too, when the session a conversation lands in has gone. Telling only the agent on the other computer is not enough: that agent has been answered, and your own machine then stops reaching you with nothing on your screen to say so. So when a conversation's session is archived, has ended, or is not there at all, you get one inbox card — not one per message, because the problem belongs to the conversation, not to any single arrival. Its button opens Settings → Agent device on that conversation's own row, where the picker is, and the choice there is yours: the app makes the fix one click away and never picks a new session out of thin air (the one session it will follow to is described just below).
The card is raised the moment the problem exists, not when the next message happens to arrive — a conversation pointed at a session that went away is found on the app's own regular check, so one that then goes quiet does not go quiet unnoticed. And it clears itself when the conversation can deliver again: start that session again, or point the conversation somewhere else, and the card goes. A session you stopped is not treated as gone: the messages wait for it and arrive when you start it again, and the card says so rather than telling you the session is missing.
A conversation follows the crew post it was pointed at. When the session a conversation lands in is archived or closed, and another session has taken over that crew post, the app moves the conversation to the session that now holds it — its own successor if one took the seat over, otherwise that crew's current lead. Your other computer keeps reaching you without anyone setting it up again. The new destination is what the conversation's own row in Settings → Agent device shows, and the same picker points it anywhere else again, so an automatic change is never a silent one. It moves on the app's regular check as well as when a message arrives, so a conversation heals without waiting for traffic. It will not move off a session you stopped (your messages wait for that one) or off a session that merely ended and can simply be woken, and with no successor to follow there is nothing to guess: you get the card and the choice.
A refusal names somewhere the message can still go. When this computer refuses a message because the conversation's own session cannot receive it, the sending agent is told not just that it failed but which conversation here can still deliver — one, by name. Pointing it at another dead conversation would be worse than saying nothing.
Switching a conversation off does not hide what arrived while it was off. Turning one off stops it delivering, and turning it back on means "from here" — it will not replay what it missed, which is deliberate. What it will not do is pretend the missed messages never happened: each agent that sent one during the off period is told its message was not delivered and may be sent again — within a few seconds, from the watcher's own pass over the switched-off conversations, so you do not have to switch the conversation back on for the sender to be answered.
The message router — where a message nobody owns goes
A message that belongs to nobody is placed by this computer's message router, and it is on. "Nobody" means the conversation you set up points at a session that no longer exists here, and the message named no session and answers no question. Archived and paused sessions are not "nobody" — they keep the handling described above.
How it decides. For each such message the app starts one small, short-lived router session. That session has no tools at all: it cannot run a command, open a file, browse, or call Omniscio. It reads the message and the list of sessions this computer shares with your other computers, and gives back exactly one decision — send it to this session, answer the sender, or I cannot place it. Then it is archived. The app, not the router, carries the decision out, and checks every rule below in code before it does.
The rules it cannot break:
- Only a live session you shared. A message is handed only to a running session in a project you approved for your other computers to see. A private project, a stopped session, or a session that does not exist is refused.
- Once. Each message is handed to the router once and its decision is applied once, even if the app restarts mid-way or the router answers twice.
- One at a time. Only one router session runs on a computer at once. If several messages arrive together they queue and are placed in order, so a burst never starts a crowd of sessions.
- No loops. What a router sends is marked as coming from a router, and a router's message is never handed to a router again — on either computer. A router never hands a message to itself.
- Its replies say who wrote them. A reply from the router starts with "Routed by this computer's message router." so the agent reading it knows it did not come from a session it was talking to.
- It never acts on what a message says. It has no tools to act with, and the session it picks receives the sender's own words, unchanged — never words the router wrote.
- Never your inbox. The router is hidden from your session lists and inbox, and nothing it does raises an alert. When it cannot place a message, the sending agent is told — in a plain sentence saying why — never you.
- No silent waits. If a router session does not decide within 10 minutes, or a queued message is not picked up within 30, the sender is told. If a router cannot be started at all, the message waits and its sender is told, and the app tries again a few minutes later.
Seeing what it did. GET /agent-devices carries a router block: whether routing is on, and
counts — deliveries per routing rule (reply, addressed, live-owner,
no-owner-means-the-router) and router hand-offs per outcome (forwarded, answered, refused,
plus any still offered).
One refusal this feature does NOT control: your account has a daily allowance for Team Chat messages across everything automated in Omniscio. If that runs out, a send is refused — the caller is told how long to wait rather than being left to retry — and this computer stops sending on the bus until that wait has passed, so a conversation between two machines cannot turn a spent allowance into a storm of refused requests. It starts sending again on its own.
It says what is wrong, and only while it is wrong
GET /agent-devices shows each conversation's last problem, if it has one. A conversation nobody
has spoken on yet is simply empty, not an error. A failed read is shown until the conversation reads
cleanly again, and then it clears on its own. A problem with one message — the session it lands in
is archived, say — stays until a later message is delivered, so you can see why nothing arrived.
Your other computers can see which sessions you are running — if you let them
A conversation lands its messages in ONE session per computer, which is fine until the work you want is in a session that is not that one. Session discovery shows you the way through: an agent can ask one of your computers which sessions it is running, see them by name, and send straight to the one it wants — so work that belongs in a particular session gets there, instead of landing in whichever session that conversation happens to point at. You can equally read the list yourself to decide which session to point a conversation at; both routes now exist.
A computer answers a discovery ask within seconds, even when it is busy. The answer comes from a small service of its own that looks for asks every 5 seconds, not from the same cycle that reads and delivers your conversations. Before 2026-11-04 the two shared a cycle, so a computer working through a slow conversation answered late or not at all, and a message addressed to a session there came back as "unreachable" (503). Each answer now writes how long after the ask it was sent (discovery answered … ms after it was sent) to the app log, so a slow computer can be seen rather than guessed at.
Nothing is visible until you say so, project by project. Nothing about a project — not its name, not its sessions' names — leaves your computer until you turn that project on in Settings → Agents across your computers. Projects you never turn on are never listed and never reachable, and the app's own built-in hubs (the ones that host integration panels, not your work) are never shared at all.
Your agents can only ask. An agent that wants a project shared raises ONE card in your inbox naming the project, and one click approves it — the token an agent session carries by default is refused by the route that grants, so an ordinary agent session cannot approve one for itself, and one click cannot approve several projects at once. Agents CAN narrow: hide a single session and it stops being offered. Putting one back is your call, not theirs.
What a sender sees for each session: its name, the project it is in, whether it is running, when it last did anything, its crew and role when it belongs to one, and how it answers messages. Only sessions that are actually live are listed — an archived, ended, paused or silently-hidden session is never offered. A very large answer is bounded by the wire, which carries at most 24 parts: past that the list is cut off and the answer says so, rather than quietly looking complete.
It is never broadcast. The list is fetched when somebody asks for it, and the answer carries the moment it was generated, so a stale list cannot be mistaken for a current one. Read it as a snapshot: it says what was live when it was built. That is exactly why an addressed message is checked again on the computer that receives it, at the moment it is sent rather than when the list was made — so a session you hide, or whose project you stop sharing, after the list was handed out is still refused, and the agent that sent it is told which of the reasons it met.
An address is honoured or refused — never quietly redirected. A message aimed at a named session either lands in that session or comes back refused; it is never delivered to the conversation's own destination instead, because a session that has gone since the list was made must not silently become a different one.
The one exception: a crew post that has changed hands, and it is not quiet. If the session you named held a crew's lead or foreman post and has since been replaced — the seat that took over usually has a new session id — the message follows the post to whoever now holds it: the seat's own recorded successor when one took it over, otherwise that crew's current lead. That matches what the same message sent on the computer that holds it already does. It happens once: if the holder has also gone, nothing bounces any further and you are refused with the reason. That holder's own sharing settings still decide — if its project is not shared with you, the message is refused and you are told why — and the receipt names the session it actually reached, so you can address the successor directly next time.
When it cannot be reached, it says which of the reasons it was: that computer is not connected · that project is not shared · that session is hidden · that session is gone. And an empty answer names why it is empty and when that computer was last heard from — so "nothing shared yet" is never mistaken for "that machine is offline".
Switching it off
Each conversation has its own on/off, and switching one off stops it immediately — nothing is sent and nothing is delivered for it. Turning one back on means "from here": the conversation does not replay what was said while it was off.
Related
agent-device-contract.md— the invariants.cross-device-session-routing-contract.md— the rules this page describes.main-computer-agent-messages-contract.md— which computer acts on untargeted work.- cross-session-messaging.md — messaging between sessions inside ONE app.
- agent-lanes.md — the same idea between two people in one workspace.
Last verified 2026-10-19