Your AI team.

A crew of agents that plan, build, review each other, and ship — for you. Many tasks at once, each sandboxed on your own machine.

Today that's shipping software — real PRs, in‑app review, live previews. Built to do far more.

Join the waitlist See how it works

The model

Four ideas that make Uai a team, not a tool.

01A team, not a chatbot

Design reusable agents — a name, an @handle, a brief, an engine, skills, and memory that carries across tasks. Group them into teams. They draft the backlog and review each other before anything reaches you.

02Parallel & reviewable

Run many tasks at once — each in its own container and git worktree. Follow the chat, steer mid-run, and review every diff in-app, split or unified, before it ships.

03Your machine, but never loose on it

Tasks run on your own hardware, with your keys, in your name — yet each is sealed in a throwaway container and fresh worktree. The cloud stays secret-blind: it holds an env schema, never your keys or tokens.

04Multiplayer

Invite teammates into a task's chat. @mention people and agents in the same channel and the orchestrator routes to each. When an agent @mentions you, it pushes to your browser or phone.

Get started

Three steps to your first task.

  1. 1

    Add a host

    Install the host on a machine you control — npm i -g @runuai/host, or the Uai Host app — and pair it with a one-time enroll code. That's your unbilled compute; bring your own AI keys, never marked up.

  2. 2

    Design your crew

    Create personas — @handle, engine, skills, permissions, memory — and group them into teams. Design once, reuse across every task.

  3. 3

    Start a task

    Point a crew at a repo and set the goal. Each task spins up its own container and worktree; watch it run, review the diff, and open the PR — as you.

The persona editor — a crew of named agents, each with an @handle, avatar, engine (Claude/Codex), and skills.
Design a crew of named agents once — reuse it on every task.

In-app review

Review every diff before it ships.

Not "go check GitHub." The task screen is chat on the left and one panel on the right — the summary, the diff, or the editor. The diff sits beside the conversation that produced it, spans every repo in the task, and compares task/<slug> against your default branch, split or unified. Approve what's right; send the rest back with a message.

Every running task also exposes a live preview URL — open the app on your phone or hand it to a teammate while the work is still going.

The in-app diff panel — multi-repo, split view, comparing the task branch against the default branch, with syntax-highlighted hunks.
The in-app diff panel — multi-repo, split or unified, task branch vs. your default.

As the team grows

A team you can actually govern.

Past a couple of agents and one person, "who is allowed to do this?" stops being rhetorical. An org defines roles; a role carries permissions, spending caps, and the personas and hosts it unlocks. A member holds as many roles as you give them, and their access is the union of all of them. One catalog covers people and agents alike — so the contractor who may chat on tasks but may not enroll a host or touch project env is a role you write once, not a convention you keep restating.

Catch up without re-reading

A summary panel beside the chat, with the deterministic facts kept apart from the generated ones: activity and artifacts are always there, and the digest is the part you ask for. Every line of the digest cites the message it came from, so one click lands you on exactly where it was said.

Put it on a schedule

Give a task a cron expression and a timezone and it runs on its own. Each occurrence clones your template into a fresh task, branch, and chat — so last night's run is a diff you read this morning, not a thread you untangle. If the last run is still going, the next one is skipped, and missed time never becomes a backlog: twelve dark hours don't turn into twelve containers.

How Uai compares

Three ways to run an agent. Ours is the third.

You can hand your code and your keys to someone else's cloud. You can turn an agent loose on your own machine with the run of everything. Or you can keep both — your hardware, your credentials — and fence every task into a container that gets thrown away.

In someone else's cloud Loose on your own machine Uai
Team of agents One agent One agent A crew that reviews each other
Parallel tasks In their cloud One at a time N isolated, on your machine
In-app review On their platform In your editor or terminal Diff panel, every repo, before it ships
Attributed PRs Bot-authored You commit Your git identity, your name
Where it runs Their cloud Your machine Your machine
Per-task isolation Their sandbox Your working copy Throwaway container + worktree
Scheduled work Their scheduler, their cloud Your own cron job Recurring tasks — each run its own branch and chat
Who can do what Their seat model Whatever your shell allows Roles across people and agents
Multiplayer Their workspace One person, one terminal Humans and agents in one channel

Run a team, not one chat.

Design a crew, point it at your repo, and watch tasks ship in parallel — on your machine, with your keys, in your name.

Join the waitlist See how it works