One agent recruits a team.

Give one agent a big job on Novastart and it does not do it alone. It drafts a plan, recruits helpers, up to ten, and sends each one to a window of its own with its own cursor. The lead keeps working while they do, then folds their results back in.

That is one agent and its team. Here is how the lead splits a job, what each helper gets, how the OS keeps them out of each other's way, and how you stay in charge of all of them.

One job, one lead.

You start with one agent and one job. Type what you want, and that agent owns it. Nothing about the size of the job changes that: there is one agent to talk to, one chat to read, one cursor to follow.

If the job is bigger than one pair of hands, the lead splits it. It drafts a plan with one task per helper. In Plan mode you see that plan before anything moves, and you can edit it before the first click. Then the steps tick off live as they run. A plan you can read is also a plan you can correct, and correcting it before anything happens is the cheapest fix there is.

It recruits helpers.

The lead recruits a helper for each task, from one to ten. Three is the default, and you set the cap: fewer for a small job, more for a big one, never more than ten per lead. Each helper gets its own seat in the OS, a virtual mouse and keyboard, and a cursor of its own on the canvas.

Helpers share the lead's colour. The lead's cursor carries an AI badge; the helpers carry AI 1, AI 2 and so on, in the same colour, so a glance tells you which team a cursor belongs to. Each helper gets a window of its own, and an organiser tidies those windows into a row or a grid beside your work. Your own windows are never moved. You keep your notes where they were while a grid of helper windows grows next door.

Ask which of four hotel pages has a room free, and four helpers open one page each and check at the same time. Ask for a trip plan, and one helper looks at flights, one at the cabin, one at lift tickets, while the lead keeps a sheet going.

In parallel, without collisions.

Helpers work at the same time, each in its own window, while the lead keeps working. The OS keeps them from tripping over each other. One agent per window is enforced: a window claimed by one cursor is not touched by another. Clicks and key chords land whole, so two agents typing at once never corrupt each other's input.

That is what makes the parallel part safe. On a desktop with one pointer, two agents would take turns with it, or fight for it. On Novastart each has its own, and the OS decides who owns which window.

Progress in one place.

You do not have to watch ten windows. Each helper's progress streams as one live line inside the lead's chat, so the lead's chat is the place to look: one line per helper, updating as it goes. When a helper finishes, it reports back, and the lead folds the result in, adds it up, or moves on to the next step.

When the whole job ends, an independent verifier looks at a fresh screenshot and checks it against the goal before the run counts as done. Every run is logged, with steps, clicks and screenshots, so you can read back what the lead did and what each helper did.

You are in charge of all of them.

A team of cursors is still under one hand: yours. Pause freezes the lead mid-click and its whole team with it. Nothing moves until you resume.

Type mid-run to steer. A note to the lead, such as Include fees, reaches the agent and its helpers, and they adjust without starting over. If a helper is in the wrong window, a plain click takes that window back: the agent lets go and parks its cursor. You can also drag any AI cursor anywhere on the board. And the lead can ask you a question when it needs an answer, so the team waits on you rather than guessing.

How many, how far.

Up to 16 agents can work on one canvas, and each can recruit up to 10 helpers. The OS reserves a seat for every one of them, 176 in all, so a full canvas of teams still gives each cursor a mouse and keyboard of its own.

Each lead runs its own team and reports to you. If you want two jobs done, you give two agents two jobs, and each one keeps its helpers to itself.

What it runs on.

Agents run on OpenAI's computer-use models. The seats, the cursors and the rule of one agent per window are Novastart's: the model decides what to click, and the OS gives it a mouse and keyboard of its own and keeps its helpers out of each other's way. If you want to build your own, the Open Virtual Input SDK comes in Python, JavaScript and Rust, and an agent you build with it gets its own cursor like any other.

Watch a team work.

The AI Agents page runs three jobs with helpers start to finish, has a stepper for the helper cap, and a run where you pause, steer and take a window back yourself. For how a single agent gets a seat of its own, read an agent you can watch. To run it, the install page has the app and Novastart OS.