The copilot

It reads the screen. You hold the switch.

Delta can look at a support session the way a second engineer would: read the error off the screen, say what to try, write the session up afterwards. Every one of those looks leaves the machine through a single function — and that function refuses to run until you have said yes.

How the gate works On the build you can download
One way out

Five surfaces. One door.

The copilot, the screen reader, the before-and-after, the timeline marker and the written report do not each open their own connection. They call the same function, and the consent check lives inside it — not in the button that started them.

  1. The check is at the exit

    A surface that forgets to ask is refused anyway. So is one written next year by somebody who never read this page. There is exactly one place where screen content can leave the machine, and the gate is bolted to it.

  2. Consent lasts one launch

    It is a flag in memory that is deliberately never written to disk. Quit Delta and it is gone; the next launch asks again. Nothing you agreed to last month is still agreed to.

  3. Switching it off is awaited

    The revoke is waited on rather than fired and forgotten. If the client cannot confirm that the gate closed, it says so — instead of showing you a switch that reads “off” over a gate that is open.

  4. The other side is told

    The first time AI touches a session, a line arrives in that session’s chat saying so. Disconnect and the next session gets its own notice, so a grant made an hour ago cannot quietly cover a stranger.

What it does

Five things, and the numbers behind them.

None of this is “powered by AI” in the abstract. Each surface is a fixed procedure with a fixed budget, and the budget is written into the client where it can be read rather than into a plan you have to trust.

  1. It watches the session

    A frame every eight seconds, and only if more than twelve percent of the pixels changed since the last one — a still screen costs nothing at all. The frame is scaled to 1024 px wide before it goes anywhere, and the three previous readings travel with it as context. Twenty suggestions are kept; the oldest falls off the end.

  2. It reads the error off the screen

    One capture comes back as the text that was on screen, the error codes inside it, and a step-by-step fix for each code with a confidence figure. The text is searchable, so a wall of log is a query instead of a scroll.

  3. Before, and after

    Take a reading of the machine, do the work, take another. What changed between the two comes back written out — so “it works now” has something behind it that a colleague can read tomorrow.

  4. It marks the moments

    A recording is sampled every ten seconds, up to fifty marks, and the errors and state changes are placed on the timeline. You scrub to the moment instead of watching the hour.

  5. It writes the session up

    A finished recording becomes a report: what was wrong, what was done, in the order it happened — built from the session’s own audit trail rather than from anyone’s memory of it.

Where it goes

Out through one gateway, and the gateway is ours.

Screen content from a support session is somebody else’s data. Streaming it to a general-purpose service outside the EU would break the promise the rest of this product makes, so the client does not have that address compiled into it.

One address
Every request goes to ai.altovar.net — our gateway, on our machines, in the EU. The keys to anything behind it stay on the gateway; the client holds one key to the gateway and nothing else.
Or your address
Point the client at a gateway you run and it will use that one. There is no second address it can quietly fall back to if yours is unreachable.
Four lanes, steered from the server
A surface asks for an effort level, not for an engine. Which engine serves that lane is decided by a routing table the gateway publishes and the client re-reads every ten minutes — so the fleet is re-steered with an edit there, never with a release here.
And a floor under it
If the table cannot be fetched, the last one seen is used. If none was ever seen, four lanes compiled into the client are. Routing degrades quietly; it does not fail open, and it does not stop working.

An image is capped at 2 MB before it is sent — and without consent a request never reaches the point where that cap would matter.

Delta’s AI Copilot settings: AI-powered screen analysis during support sessions, an API key stored locally and never shared, and the gateway ai.altovar.net.Delta’s AI Copilot settings: AI-powered screen analysis during support sessions, an API key stored locally and never shared, and the gateway ai.altovar.net.
Settings → AI Copilot
On the build you can download

Built, and not yet reachable.

On the build you can download, none of the five surfaces above can be opened. Here is exactly why, measured against the same artifact whose hash our download page publishes.

  1. Every AI panel lives in the shared session

    The copilot, the screen reader, the before-and-after and the recording controls are all mounted in one view — the session you start from “Share Link”. The ordinary remote-desktop window has none of them.

  2. The Linux build cannot open that session

    We ran the released AppImage and pressed Share Link. It stops at “session sharing is not configured on this installation”. Behind that sits a second wall: the webview the AppImage carries has no WebRTC at all — we read the value out of the library the app itself loads, not out of a system one.

  3. The fix is written, not released

    A build that carries a webview with WebRTC turned on is merged into the product’s trunk. Until a release ships with it, this page describes an architecture you can read rather than a feature you can use — and we would rather you learn that here than after the download.

Two claims came off this site the day we measured them. Voice commands: the speech API they need is absent from the webview we ship, and where it does exist the audio would leave through somebody else’s service. The knowledge base: the view is there and it can search, but nothing in the product can write the articles it would search.

Read the rest of it.

The copilot is one part. The handshake underneath it, and the thirty-eight things the client does without any AI at all, are worth the same scrutiny.

Walk a session How the handshake works Download for Linux