Your AI Ecosystem.
A crew of agents that plan, build, review each other, and ship — for you. Six engines, your own keys, and every task sandboxed on the runner you choose — your machine, or our cloud.
Software is where it's sharpest — real PRs, in‑app review, live previews. This page was rebuilt today by a crew of four: a CMO, a designer and two engineers.
- Mira, Architect
- Otis, Reviewer
- Juno, Frontend
- Kit, QA Automation
- Remy, DevOps
- Sol, API Designer
The model
Four ideas that make Uai an ecosystem, not an assistant.
01Agents you own, not an assistant you rent
A chat session forgets when you close the tab, and it's the same one
everyone else gets. An agent here keeps what it learns — written
down under its own @handle, and still
there on the next task.
02Parallel & reviewable
Many at once only works if you can still read all of it. Each
task takes its own container and git worktree — ten
tasks running is ten separate branches, not one tangled checkout.
03Your choice of runner, but never loose on it
You pick where the runner lives — your infrastructure, or ours. Either way, every task is sealed in a fresh workspace that's destroyed when it ends. Self-host it — a machine you keep, or your own AWS account — and the cloud stays secret-blind: an env schema, never your keys or tokens.
04Multiplayer
Invite people into a task and @mention them beside
the agents; when one @mentions you back, it lands on your
phone. A role decides what each may do, so the contractor you bring
in gets exactly the agents and runners you allow.
Get started
Three steps to your first task.
- 1
Add a runner
Install the runner on a machine you control and pair it with a one-time enroll code. That's your unbilled compute; bring your own AI keys, never marked up.
- 2
Design your crew
Create the agents you want and write each one a brief in its own words. Group them into teams. Design once, reuse them on every task.
- 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.
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
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.
While you're away
Work keeps moving when you're not watching.
Catch up without re-reading
A summary panel beside the chat: activity and artifacts always there, the digest the part you ask for. Every line of it cites the message it came from, so one click lands on 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 is skipped: twelve dark hours never become twelve containers.
How Uai compares
Three ways to run an agent. Ours is the third.
A hosted platform runs your work somewhere you can't look. An agent loose on your machine runs it everywhere it can reach. Here's where that difference lands.
| Hosted agent platforms | An agent loose on your machine | Uai | |
|---|---|---|---|
| Whose name is on the commit | It lands as a bot. | Yours — you're the one typing. | Yours. Agents commit with your git identity. |
| Reviewing the work | On the platform that wrote it. | Whatever your editor and terminal give you. | A diff beside the chat that produced it — every repo in the task, before it ships. |
| Per-task isolation | A sandbox you can't inspect. | None. It works in your real checkout. | A fresh container and worktree per task, deleted when it ends. |
| Who picks where it runs | You don't. There is one place. | Your machine, or nothing. | You do — your infrastructure, or ours. |
Both keep every task sealed in a fresh workspace, destroyed when it ends. What differs is who holds the keys.
Your infrastructure
- Keys
- You hold them.
- Compute
- Never billed by us.
- Setup
- One command, plus an enrol code from the app.
- Pick this if
- You want the keys to stay with you — or you have compliance, residency or procurement to answer to.
Uai Cloud
- Keys
- We hold them — in our KMS.
- Compute
- You pay for the hours you use.
- Setup
- Pick it in the app. No command, nothing to install.
- Pick this if
- You want to start now and never think about infrastructure.
Questions
The things people ask first.
The rest live where they belong — the trust model on security, seats and limits on pricing.
Do commits and PRs show up as a bot?
No. Every task runs with your own credentials — your git identity, your per-user SSH key, and your GitHub user token — so commits and pull requests attribute to you, not a bot.
Do I need a GPU?
No. Uai orchestrates AI agents that call hosted models — currently Claude, Codex, Kimi Code, Grok, Cursor, and OpenCode; the runner advertises which engines and models it can run — with your keys. No local inference, no GPU requirement.
What if I want to edit the code myself?
Every task has a code-server editor pane — VS Code in the browser — alongside the chat.
Do you mark up tokens or charge for inference?
Not on your own keys. Your agents run on your own AI keys and you pay the model provider directly — we never mark up those tokens. Seats buy orchestration capacity (parallel tasks, agents, runners) and collaboration. If you choose to run through the Uai engine or on a Uai Cloud runner instead, that usage is metered from credits at the rates listed in the app — every seat brings monthly credits, and you can add more.
Can I control what each person can do?
Yes, with every seat — and on Free. A workspace defines roles: a role carries permissions, caps, and the personas and runners it unlocks, and a member can hold several — their access is the union. The same catalog governs your agents, so the rule for a human and the rule for an agent's CLI can't drift apart. Role caps only clamp down against your plan, never up: a role distributes the capacity you already bought. New workspaces start with two roles, Workspace Admin and Member, and Member grants exactly what a member could always do — nothing narrows until you narrow it.
Can I share work with my team?
Yes. Every account is a workspace. Free is solo (one member); a subscription owns seats and every seat holds a member — there is no cap on how many — so invite people into the workspace and collaborators into a task's chat, and @mention agents and people in the same channel. Each task carries its creator's own credentials, so commits and PRs attribute to the actual person.
Run a team, not one chat.
Design a crew, point it at your repo, and watch tasks ship in parallel — on the runner you choose, with your keys, in your name.