The problem with watching someone else's screen

Screen sharing is one-way. The person sharing has the mouse and keyboard; everyone else is an audience. If a teammate spots the fix, they have to describe it in words and wait for someone else to carry it out. Ideas get lost in translation, and time goes into narrating clicks instead of doing the work.

It also splits work into separate machines. Each person has their own desktop, their own windows and their own layout. Collaboration means trading links, attachments and screenshots instead of working on the same thing at the same time.

A shared canvas instead of a shared screen

Novastart replaces the traditional desktop with one infinite canvas, giving users more space for their everyday work. Every app sits on that canvas. Users scroll and pan to move between apps and zoom out to see everything at once, and each canvas reopens exactly as it was left.

That canvas can be shared. Teammates join a shared canvas by email invitation. Once they're in, they don't just watch: they click and type in one another's windows at the same time, from their own computers. Two people can work in the same app, or one can fix a spreadsheet while another drafts an email nearby, all on the same canvas.

Direct, machine to machine

In Novastart, windows stream directly from machine to machine, so the whole team works together on the same canvases. The result is closer to sitting side by side at one computer than to watching a presentation. Everyone has their own input, everyone sees the same workspace, and nobody has to ask for control.

Built for the apps teams already use

A shared workspace only helps if the tools are there. Novastart opens more than 30 web apps, including Chrome, Claude, ChatGPT, Gmail, Excel, WhatsApp and Notion, as standalone windows. A team can lay out the apps a project needs across one canvas and work in them together, instead of each person juggling their own copy.

Room for AI agents on the same canvas

The shared canvas isn't only for people. In Novastart, AI agents can click and type with cursors of their own. Each agent gets its own mouse and keyboard inside the operating system, so multiple agents can work at the same time. A lead agent splits a job among up to 10 helpers, each with a labeled cursor in its own window. Users can watch every agent's clicks, pause or correct a run midway, and take a window back with one click.

"As AI gets more powerful, it becomes more important to see what agents are working on for us," said Thomas Fraher, co-founder and CTO of Novastart. "We built that into the operating system. Every agent has its own cursor on the same canvas as you, and nothing happens where you can't watch it."

For a team, that means people and agents working in one visible space, with every cursor accounted for.

What changes when you stop screen sharing

When collaboration happens on a shared canvas instead of a shared screen, a few things shift:

• Everyone can act. Teammates click and type directly instead of narrating.
• Work happens in parallel. Several people can work in different windows at the same time.
• The workspace persists. Each canvas reopens exactly as it was left, so the team's setup is still there next time.
• Nothing is hidden. Teammates and AI agents all have visible cursors on the same canvas.

Getting started

Novastart is available now in three plans: Free, Pro and Team. The Novastart app runs the full operating system in a window on Windows 10 or 11 and on Intel-based Macs. Novastart OS installs as the operating system on Intel and other x86 PCs from a USB drive in about 8 to 15 minutes.

Novastart was founded by brothers Thomas and Nick Fraher and is based in Los Angeles, CA. If your team spends its days asking "can you see my screen?", it may be time to share the whole canvas instead. Learn more at novastart.com.

These are design priorities rather than a claim that every current product provides them fully. Novastart makes the discussion concrete through its canvas and visible agent participation. The broader question is what a workspace needs when a human and software assistance share the same project.

The task should have an explicit shape

The workspace should make the goal, sources, and expected output identifiable. An agent asked to prepare a recommendation needs more than an open browser. It needs the criteria, evidence, and a definition of completion. A readable project area can help connect those parts, provided the assignment itself remains precise.

The system should also preserve uncertainty. A missing answer should remain missing, and a tentative source should not become a confirmed fact merely because an agent writes confidently. The final output needs a route back to the evidence. That makes review practical and helps the person judge what the work actually establishes.

Agent activity should be understandable

Visible participation can help a person notice that the agent is inspecting the wrong source or pursuing an irrelevant branch. The workspace should explain the role of the activity, not merely show a moving pointer. A person benefits from knowing which part of the assignment is underway and how it relates to the final output.

Observation should not demand constant micromanagement. Meaningful checkpoints can be more useful than watching every action. Review the selected sources, inspect an early sample, and check the final result. The design should support those moments clearly enough that the human can supervise without turning assistance into a more laborious version of doing the task alone.

Human control should remain available

A person needs a clear way to correct an assignment and understand the effect of the correction. If the goal changes, the agent should not continue as though nothing happened. The interaction should make it possible to state the new requirement and determine which work remains applicable.

Important boundaries should also be understandable. Preparing a draft and making an external commitment are different stages. A workspace designed for agents should help people identify the stopping point and the decision needed before proceeding. This is useful product behavior because it reduces ambiguity about what the person asked the assistance to complete.

Parallel agents need coordination

Several agents should have distinct responsibilities and compatible outputs. A shared project map can show the branches, but it cannot substitute for task design. The system should help identify who owns the final synthesis and how individual findings will be combined. Otherwise, parallel work can produce conflicting edits or incomparable summaries.

The human should review the synthesis separately. Correct findings can still lead to a poor recommendation if the wrong criteria are weighted or unlike figures are compared. A useful system keeps the evidence traceable and the unresolved questions visible. It should make careful acceptance easier rather than encourage trust because many agents appeared busy.

Applications and identity still matter

Agents interact with real tools, accounts, and files. The workspace should help a person understand the current context and where changes are saved. A familiar-looking window is insufficient if the agent is working in the wrong account or on an outdated copy. Clear identity and authoritative locations remain essential to reliable work.

The agent's output should fit the established project workflow. Code needs a maintainable change record, a document needs a reliable file, and a decision needs a durable explanation. A new operating-system model should support those records rather than create an opaque parallel history that only the live session can explain.

Design around reviewable work

The most valuable agent-oriented operating system helps a person understand and govern the work without unnecessary effort. It connects a clear assignment to visible activity, traceable evidence, and a result that stands on its own. That is a stronger design goal than simply allowing an agent to click more applications.

Evaluate the idea with one bounded task. Check whether the human can correct a misunderstanding, inspect the output, and continue the project afterward. An operating system built for agents should strengthen human judgment by making the relevant work easier to see and assess.

Windows, macOS, and most Linux desktop environments still rely on roughly the same model:

• applications open inside windows

• windows live inside a fixed desktop

• one mouse controls one pointer

• one keyboard controls the active application

• users switch between apps, tabs, and virtual desktops

That model works.

But it was designed around a very different computing environment.

Today, developers routinely work across dozens of applications, multiple monitors, remote machines, AI tools, cloud dashboards, terminals, browsers, and collaborative environments.

That raises an interesting question:

What would an operating system look like if we designed it from scratch for modern workflows?

One possible answer is an infinite canvas.

The Desktop Shouldn't End at the Edge of the Screen

A normal desktop is constrained by the physical dimensions of your monitor.

You can add virtual desktops, but each one is still fundamentally another rectangle.

An infinite canvas changes the model.

Instead of your screen being the workspace, your screen becomes a viewport into a much larger workspace.

Applications can be positioned anywhere on a two-dimensional plane.

For example:

                       Research

               Browser     Documentation


Project A                                  Project B

VS Code                                    Figma
Terminal                                   Browser
Database                                   Slack
GitHub                                     Analytics


                       AI Workspace

                Agent 1     Agent 2

The user can pan around the environment and zoom between different levels of detail.

Zoom out and you see your entire workspace.

Zoom in and individual applications behave like normal windows.

The operating system starts to feel closer to tools like Figma or a collaborative whiteboard, except the objects on the canvas are real applications.

Spatial Organization Becomes Part of the Interface

Most operating systems optimize for switching.

You switch applications.

You switch windows.

You switch tabs.

You switch desktops.

An infinite canvas makes spatial organization another option.

Imagine having persistent areas for:

• frontend development

• backend services

• analytics

• customer support

• product design

• infrastructure

• research

Instead of remembering which virtual desktop contains something, you remember where it is physically located on your workspace.

That may sound subtle, but spatial memory can be incredibly useful.

You may not remember the exact filename of something, but you remember:

"That browser was next to the terminal in the upper-right part of the project."

The canvas becomes part of your mental model of the work.

The Data Model Is Surprisingly Simple

At a high level, an infinite canvas doesn't necessarily require every application to understand that it lives on one.

The operating system can maintain metadata for each window.

For example:

{
  "windowId": "chrome-83",
  "x": 4820,
  "y": -1240,
  "width": 1440,
  "height": 900,
  "zIndex": 14,
  "canvasId": "product-development"
}

A user's viewport might separately contain:

{
  "x": 4100,
  "y": -900,
  "zoom": 0.72
}

The visible display is then just a projection of that larger coordinate system.

Conceptually, this is similar to how design applications handle large canvases.

The major difference is that the objects aren't rectangles representing graphics.

They are application windows.

Collaboration Makes the Architecture More Interesting

Once the canvas becomes persistent state, sharing it becomes possible.

Instead of sending someone a screenshot or sharing your entire screen, another user could connect to the same operating system environment.

Both users could see the same underlying workspace.

That creates a synchronization problem.

If one user moves a window:

x: 500 → 850
y: 300 → 620

other connected users need to receive that change.

A shared state object might look something like:

{
  "windowId": "terminal-21",
  "x": 850,
  "y": 620,
  "width": 1000,
  "height": 700
}

Technologies such as CRDTs are particularly interesting for this kind of environment because multiple users may update shared state concurrently.

Instead of synchronizing a document, you're synchronizing an operating system workspace.

Screen Sharing Is the Wrong Abstraction

Traditional screen sharing assumes one rendered screen.

That becomes problematic when multiple users want to work simultaneously.

Consider two remote users:

User A
→ looking at the marketing area

User B
→ looking at the engineering area

If the system streams one desktop framebuffer, both users are forced to look at the same viewport.

A more interesting architecture is per-window streaming.

Each application window can be captured independently.

A user's client can then compose those streams according to that user's own viewport.

So User A might receive:

Chrome
Analytics Dashboard
Slack

while User B receives:

VS Code
Terminal
GitHub
Documentation

Both sets of applications can still belong to the same underlying OS environment.

The difference is that each user controls their own view.

Multi-Seat Input Is Another Challenge

Most desktop systems assume a single active pointer and keyboard focus.

Even if you connect several mice, they usually control the same cursor.

That model breaks down if multiple people are using the same shared operating system.

A multi-user system needs independent input seats.

Conceptually:

Seat 1
Pointer A
Keyboard A
Focus: Chrome

Seat 2
Pointer B
Keyboard B
Focus: VS Code

Seat 3
Pointer C
Keyboard C
Focus: Terminal

One user's click shouldn't steal another user's pointer or keyboard focus.

This becomes even more important once AI agents enter the system.

AI Agents Could Become OS Users

Most AI systems today interact with users through chat.

Computer-use agents introduce a different possibility.

An AI system can interact directly with graphical applications.

If every agent receives an independent input seat, you could have:

Human
→ writing code

Agent 1
→ researching API documentation

Agent 2
→ testing a web application

Agent 3
→ updating project data

Agent 4
→ reviewing analytics

All operating concurrently.

Instead of an AI being something you occasionally ask a question, it becomes another participant inside the workspace.

The operating system needs to understand humans, remote collaborators, and AI agents as independent actors.

Building Around These Ideas

This is the architecture we're exploring with Novastart, an operating system centered around an infinite collaborative canvas.

The core idea combines three concepts:

1. Infinite Canvas

Applications, files, and workspaces exist inside a zoomable and pannable coordinate system instead of being limited to the visible screen.

2. Shared OS

Multiple users can connect to the same underlying operating system environment while maintaining their own viewport.

3. Independent AI Agents

Computer-use agents receive independent input seats so they can operate applications alongside human users.

That creates some unusual engineering problems around:

• input routing

• focus management

• real-time synchronization

• permissions

• window capture

• video streaming

• state persistence

• viewport composition

• application ownership

• concurrent interaction

Those problems are difficult, but they also suggest that the traditional desktop model isn't the only possible way to organize a computer.

The Desktop Metaphor Can Still Evolve

The traditional desktop isn't going away.

For many workflows, a normal window manager is incredibly effective.

But the environment around it has changed.

Computers now have:

• much larger displays

• cloud-connected applications

• remote collaboration

• increasingly capable AI agents

• distributed teams

• persistent online workspaces

An operating system designed around those assumptions could look very different from one designed around a single keyboard, mouse, and monitor.

Maybe the next major desktop interface isn't a better taskbar.

Maybe it's removing the boundary of the desktop entirely.