> ## Documentation Index
> Fetch the complete documentation index at: https://docs.unify.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Team assistants

> Assistants owned by the team itself — no single supervisor, shared memory by construction

Sometimes an assistant shouldn't belong to anyone. A repairs coordinator
for the whole repairs unit, a reporting assistant the entire finance team
leans on, a company-wide helper in the Org team — for these, "pick someone
to own it and tell them to share everything" is the wrong shape. **Team
assistants** make the team itself the owner: no single supervisor, no
private memory, and everyone on the team can work with it as naturally as
with a colleague.

## What makes a team assistant different

<CardGroup cols={2}>
  <Card title="The team is the owner" icon="user-group" color="#7a5fc9">
    No individual holds a supervisor position. The person who ran the hire
    is recorded only as the hiring member; management rights belong to the
    org's admins, like any shared resource.
  </Card>

  <Card title="The team pool is its memory" icon="brain" color="#c95f5a">
    A team assistant has **no personal contexts at all**. Everything it
    knows, learns, schedules, and stores lives in its owning team's
    shared pool — visible to every member, by construction.
  </Card>
</CardGroup>

The memory point is worth dwelling on, because it's a genuine privacy
model, not just a default:

* A personally-supervised assistant keeps a private pool and *chooses*
  when something belongs to a team. A team assistant has nothing to
  choose between — its knowledge, playbooks, skills, tasks, data,
  transcripts, and credentials all live at the team scope. There is no
  hidden layer only one person can see.
* Its working state defaults to the **owning team's** pool. If it also
  joins other teams, it can read and contribute to those pools like any
  member — but its home never moves.
* Because everything is team-visible, a team assistant is exactly as
  auditable as the team itself: open the team in the sidebar and every
  brain section shows the full picture.

## Hiring one

Team-first is the default. The hire dialog includes an **Owning team**
selector, pre-set to the team you hired from (or the managed **Org** team
where org-wide sharing is on):

* **Pick a team** → you get a team assistant, born into that team: it's
  enrolled automatically, appears under the team in the sidebar with a
  **Team-owned** badge, and its memory starts at team scope from the
  first message.
* **Pick "Personal (only you)"** → you get the classic
  personally-supervised assistant instead, with a private memory and
  optional team memberships layered on.

The fastest route for a specific team: open the team in the sidebar,
switch to **Members**, and use **Hire for this team** — the owning team
comes preselected.

Everything else about hiring — profile, voice, its own accounts, phone
numbers, and mailboxes — is identical to any hired teammate; see
[Hiring](/hiring/overview). A team assistant still gets **its own
identity** in your org's tools; what changes is who it answers to.

## Working with one

Anyone on the team can message a team assistant directly, work with it in
the [team group chat](/teams/overview#where-you-see-teams), assign it
tasks, and see everything it's doing. There's no privileged channel — the
hiring member's messages carry no more weight than anyone else's.

Because its transcripts and tasks live at team scope, the whole team sees
one coherent history: what it was asked, what it did, what it scheduled.
Its scheduled work runs on the team's task surfaces, so runs and results
are team-visible too.

## Teams, plural

A team assistant always has **exactly one owning team** — that's where its
memory lives and who it belongs to. On top of that it can join any number
of other teams, exactly like any assistant: each extra membership adds
that team's shared pool to what it can read and contribute to.

Two structural rules keep ownership coherent:

* **It can't leave its owning team.** Removing it from the owning team is
  refused — that pool *is* its memory. (Other memberships can be added
  and removed freely.)
* **The owning team can't be deleted while it owns assistants.** Deleting
  the team would delete their entire minds; the platform refuses until
  the owned assistants are deleted first.

<Tip>
  Want an assistant the *whole company* can use? Hire into the managed
  **Org** team (on by default for new organizations). Its membership is
  automatically everyone — current and future — so "owned by the Org team"
  means "belongs to the company."
</Tip>

## Spend, caps, and attribution

Team assistants bill the **organization's** account, and their cost
controls are team-shaped rather than person-shaped:

* **Caps are managed by org admins.** Any member with assistant-management
  permissions can set or change a team assistant's monthly spending cap —
  the hiring member holds no special position.
* **The org cap is the ceiling.** A team assistant's cap is bounded by the
  organization's spending cap only — no individual member's personal cap
  constrains a team asset.
* **Limit alerts go to the org's Owners and Admins** (alongside the hiring
  member), so the people who can act on a cap are the ones told when it's
  reached.
* **Spend is attributable per team.** The organization's spending
  breakdown can be scoped to a team, aggregating across every assistant
  that team owns — so "what does the repairs team's AI staff cost?" is one
  query, not a spreadsheet.

## Which ownership model to choose

|                   | Personally-supervised                                  | Team assistant                               |
| ----------------- | ------------------------------------------------------ | -------------------------------------------- |
| Best for          | An assistant that works *for you* with private context | A shared specialist the whole unit relies on |
| Memory            | Private floor + team pools it joins                    | Owning team's pool, entirely                 |
| Who can direct it | Its supervisor; teams it joins                         | Anyone on the team                           |
| Management rights | Its supervisor                                         | Org admins                                   |
| Billing anchor    | Supervisor's caps apply                                | Org cap; per-team attribution                |
| Lifecycle         | Supervisor manages                                     | Tied to the owning team                      |

Both models coexist freely in one org — and in one team. The question to
ask is simply: *if the hiring person left tomorrow, should this assistant
carry on unchanged?* If yes, it's a team assistant.
