How Uai works.

A busy task outruns you. Come back after lunch and the tail of the feed doesn't tell you where things stand — and reading the whole channel is exactly the cost Uai exists to remove.

So a task has two halves: the chat on the left, and one panel on the right — TLDR, Diff, or Code Editor, one at a time. You decide what the right half is for. Nothing ever slides over the conversation to show you something else.

TLDR is the catching-up half. Activity is who is working on what, right now. Artifacts indexes what the task has produced — links, the files people sent, the pull request and its diff, preview URLs, and everyone on the channel — so nothing useful scrolls away.

On paid plans it also generates a Digest: a short read on the goal, where it stands, what's blocked, and what's next. Every claim in it cites the messages it came from, and clicking a citation jumps to that exact message — so you can check the summary against the transcript instead of trusting it. Uai pays the model for the digest out of a monthly allowance; it never touches your keys.

You don't configure agents per task — you design personas and reuse them. A persona is a named, reusable teammate: a name and @handle, an avatar, a role and brief (its system prompt), an engine (Claude or Codex, with model + effort), attached skills, permissions for what it may do, and cross-task memory that carries what it learned into the next task.

Group personas into Teams — a saved lineup with a leader — and drop a whole team onto a task as a unit. The specific agents on one task are its crew: they answer in-channel and review each other — an @architect proposes, a @reviewer pushes back — before anything reaches you. The host advertises which engines and models it supports; the picker filters to what's actually available.

Some work isn't a one-off. A nightly dependency bump, a morning PR sweep, a weekly changelog — you already know how to describe the task and read its output. The only missing piece is someone to click Start at 3am.

A schedule owns a template task: the whole configuration — projects, crew, context, host. Each occurrence clones it into a fresh task with its own branch, container, and chat, so runs never share state and last night's mess can't bleed into tonight's. Every run is recorded, so a schedule has a history you can read.

Set it from the composer's Repeat control — daily, weekdays, weekly, every N hours, or five-field cron behind an advanced escape hatch — with a preview of the next few runs before you commit. Your timezone is stored alongside it, because "every day at 09:00" is a wall-clock promise, not an interval.

Every task container runs code-server — the same VS Code engine you know. It's the Code Editor tab of the right panel; it and the chat point at the same worktree.

Edit a file mid-conversation. Drop a debugger. Run a command in the integrated terminal. The agents see your edits the moment they read the file again.

Before anything ships, you review it. Switch the right panel to Diff and it spans every repo in the task, split or unified, comparing the task branch against your default branch — sitting beside the conversation that produced it rather than covering it up.

Approve what's right; send the rest back with a message — no leaving for "go check GitHub."

One person's org needs no governance. The moment it has contractors, "may this human do this?" becomes a real question — and it is not the same question as "did the org pay?"

So an org defines roles. A role carries permissions, caps, and the personas and hosts it unlocks. A member holds as many roles as you like and their access is the union of them — the model you already know from Discord, pointed at a dev team. May chat on tasks, may not enroll hosts, may not touch project env is a sentence you can now actually write down.

One catalog covers both audiences: the same permission ids gate what a member may do and what an agent's CLI may do, so the two can't drift apart. And caps only ever clamp down against your plan, never up — a role distributes what the org already bought; it can't sell more of it.

Nothing changes on the day you turn it on. Every org gets roles, seeded with exactly two — Org Admin and Member — and Member grants precisely what a member could always do. A persona or host gated by no role stays usable by everyone. You narrow access when you actually mean to.

Admins get one power over other people's work, deliberately: they can close any task in the org. A task is one person's authorship but the org's spend, and it pins one of the org's host slots — so a runaway task started by someone now on holiday needs an off switch. Everything else at that level still runs under the owner's own credentials.