What people use Uai for.

Six scenarios where "one chat at a time" stops paying its rent and a board of parallel tasks does.

The refactor sprint

You've been meaning to clean up the same shape across ten files. Each change is small but the context-switch tax is real, and the diff is too big to review as one PR.

With Uai:

Spawn ten tasks from the same project, each scoped to one of the files with a tight kickoff prompt.
Open the chat for each one to nudge as needed; let the agents run while you write code in another tab.
Read each diff in the app, side by side, before anything leaves the machine. Ship the ones that landed well; send the rest back with a message.

Without Uai: open the same file ten times, chat ten times, manually keep the conversations from mixing, push ten branches.

A board of parallel tasks running at once, each in its own container and worktree.

The multi-repo migration

You're adding a field that touches the API, the web client, and the mobile app. One task, three repos, one shared mission.

With Uai:

Create one task that selects all three repositories. They clone side by side at /workspace/api, /workspace/web, /workspace/mobile.
Set the global context once: "Add a nickname field on User; propagate to GraphQL + the profile screen."
Agents work across the three trees. One branch name spans all three worktrees; one click opens three PRs.

Without Uai: three terminals, three branch names to remember, the constant low-grade panic that the API change and the client change drift apart.

One task spanning three repos — each in its own git worktree on the same task branch.

The frontend redesign with live preview

You're iterating on the homepage. The designer wants to see each attempt without you booking time on a call.

With Uai:

One task per direction you want to try. Each has its own preview URL (<taskId>-web.preview.runuai.com).
Share the URLs in Slack. The designer reviews on their phone, gives feedback per option, no environment juggling.
The winners get refined in their own task; the losers get closed and the worktrees vanish.

Without Uai: three branches, one dev server, mentally swap which branch is checked out before each screen-share. A new vercel deploy per variation if you have the patience.

A task's live preview URLs on a phone — public, cookie-free links to share with a designer.

The bug-backlog Saturday

Twenty open issues, most of them small. A free morning. You don't want to babysit any single one.

With Uai:

Paste the issue list at a planner persona. It files the backlog as task drafts — one per issue, fully configured, all of them inert until you hit Start on the ones worth doing.
Tasks run in parallel. Check back in every twenty minutes. Some finished, some stuck — nudge the stuck ones, close the boring ones, merge the good ones.
By lunch, the backlog is half its old size and you got coffee twice.

Without Uai: one chat, one context, twenty serial conversations. Sunday tomorrow.

An issue list turned into a backlog of task drafts — one per issue, each awaiting Start.

The night shift

The chores nobody schedules because nobody wants to be the one awake for them: the dependency bump, the flaky-test sweep, the changelog nobody wrote. Each is a task you already know how to describe. The only missing part is someone to click Start at 3am.

With Uai:

Configure the task once — projects, crew, context, host — and set Repeat on it. That configuration becomes a template; it doesn't run, it gets cloned.
Every night at the hour you picked, in the timezone you picked, the template clones into a fresh task with its own branch, container, and chat. No shared state between runs, so Tuesday can't inherit Monday's mess.
If last night's run is somehow still going, tonight's is skipped rather than doubled. If the cloud was down for a day, you get one catch-up run, not a queue of them. Five failures in a row and the schedule disables itself and tells you.
You read the run history over coffee and review the diffs that are worth reviewing — the same in-app diff panel, on work that happened while you were asleep.

Without Uai: a cron job that shells out to something, no chat to read when it goes wrong, and no diff to approve before it does.

The org with contractors in it

Two contractors join for six weeks. They should be able to chat on tasks and open PRs. They should not be able to enroll a host, edit project secrets, or commit the org to a nightly job that outlives their engagement.

With Uai:

Build a role that grants exactly what the work needs. Permissions, caps, and which personas and hosts it unlocks — one member can hold several roles, and their access is the union.
The same catalog governs your agents. The permission that lets a human open a PR is the permission that lets an agent's CLI do it, so the rules can't drift apart between the two.
Caps in a role only clamp down against your plan, never up — you're distributing capacity you already bought, not selling more of it.
Everyone works in the same task chats: @mention people and agents in one channel, share a preview URL, and every commit still attributes to the actual person who owns the task.
Six weeks later you revoke the role. A schedule someone left running re-checks its owner's permissions on every single fire, so it stops on its own rather than outliving the grant that created it.

Without Uai: everyone is an admin, or nobody can do anything, and the difference is a conversation in DMs.

One task chat with people and agents in it — humans and personas @mentioned in the same channel.

Which one is your Saturday?

Pick a backlog, point a crew at it, and let the parallel tasks run while you review the diffs.

Join the waitlist How it works