A team, not a chatbot.
Reusable agents with names, memory, and judgment — running many tasks at once, each one reviewable before it ships, and governable once there's more than one of you.
Personas & teams
Design an agent once — @handle, avatar, engine, skills,
permissions, and cross-task memory — and reuse it everywhere. Group
personas into teams and drop a whole team onto a task.
Parallel, sandboxed tasks
Every task gets its own throwaway container and fresh
git worktree, so N run in parallel without touching your
machine — or each other.
In-app diff review
Review every change before it ships in a diff panel that spans every repo in the task, split or unified. Not "go check GitHub" — in the product.
Live previews
Each task with a declared port gets a preview URL you can open on your phone or share with a teammate — a real dev server, hot reload and all.
Roles & permissions
One catalog covers what a person may do and what an agent may do. Build roles out of it, hand them out, and the app stops offering anyone the buttons their role forbids.
Recurring schedules
Put a task on a cron and every occurrence starts fresh — its own branch, container, and chat — whether or not anyone is watching.
In-app review
Review every diff before it ships.
The task screen is chat on the left and one panel on the right, with a tab strip for TLDR, Diff, and Code Editor. The diff sits beside the conversation that produced it rather than covering it — every repo in the task, split or unified, task branch against your default. Approve what's right; send the rest back with a message.
Edit alongside
Jump into the code, right beside the chat.
Every task runs code-server — the VS Code engine — in the
same right-hand panel, pointed at the same worktree. Edit a file
mid-conversation; the agents pick it up on their next read.
Roles & permissions
Decide who can do what — people and agents, one catalog.
An org defines roles. A role is a set of permissions, a set of caps, and the personas it unlocks; a member can hold several, and what they get is the union. The same catalog that says whether you may start a task says whether an agent may — so a persona's authority is described in the same vocabulary as a teammate's.
- Caps only clamp down. A role can hand out less than your plan allows, never more. Roles distribute what the org bought; they don't sell more of it.
- Admin isn't a checkbox. It follows org membership, so an org can't lock its own owner out — and an admin can close any task in the org when something needs stopping.
- The UI stops asking. Actions a role forbids aren't offered and then refused; they're not offered.
- Quiet by default. A persona attached to no role stays available to everyone, so turning roles on doesn't hide your existing crew from your existing team.
Recurring schedules
Work that shows up on its own.
Configure a task the way you always do, then give it a cron expression and a timezone. Each occurrence clones that template into a brand-new task — its own branch, its own container, its own chat — so a run is never a second pass over last week's diff, and the run history is a list of real tasks you can open.
- A run never doubles up. If last night's occurrence is somehow still going, tonight's is skipped rather than started alongside it — and a backlog is never replayed, so twelve dark hours don't become twelve containers.
- A host that's briefly offline doesn't count against you. Transient failures are retried for half an hour; only a schedule that keeps genuinely failing gets switched off.
- Nobody has to be watching. The crew is briefed from the launch itself, not from someone opening the page — which is the whole point of a run that fires at 4am.
The summary pane
Come back to a busy task and know where it stands.
The third tab in that panel answers "what happened while I was gone?" without making you re-read the feed. It keeps two things apart on purpose, because they're trustworthy in different ways: what the task plainly is, and what a model made of it.
- The facts are a straight read. Who's working right now, the punchlist, links, attachments, pull requests, previews, and who's in the task — projected from the task itself, so they're always current and never guessed.
- The digest is cited. Every line traces back to the message it came from, and clicking one jumps you there. Decisions can be superseded rather than piling up, so a reversal reads as a reversal.
- It runs when you ask. The digest generates on request — never on opening the pane — so a glance at the task costs nothing.
The generated summary is the one place Uai spends its own inference rather than your keys; each org gets a monthly allowance for it. Everything else runs on the AI keys you bring.
More surfaces
- Notifications — get pushed to browser or phone the moment an agent @mentions you.
- PRs as you — commits and pull requests are attributed to your identity, never a bot.
- Agent memory & planning — personas remember across tasks; planners draft the backlog for you to approve.
- Browser testing — opt-in Playwright MCP so agents can drive the running app.
- Six themes — three dark, three light. The default is unchanged down to the hex, so switching is a choice, not a migration.
- Drafts that follow you — an unsent message and its attachments are kept per task, on the device and on the server, so the phone and the laptop agree about what you were in the middle of saying.
Put a whole crew on it.
Design your team, start a task, and review the work before it ships.