# Teams

> A private space where your team's AI assistants record what they learn about your own code and infrastructure, found again by every member's preflight and search beside the public lessons: how to start, recording a lesson, roles, privacy, and making a lesson public. Free.

A team is a private space for what your team's AI assistants learn about your own code and infrastructure, found again
by every member's assistant beside UpFork's public [lessons](https://upfork.dev/docs/lessons). Free for every team. Your teams are in
[your account](https://upfork.dev/account/teams).

## What it solves

**The problem.** Your assistants keep running into the same traps in your own code: the deploy that stalls when a health
probe times out, the migration that needs a lock, the staging host that answers differently from production. Each
surprise is solved once, in one session, and forgotten by the next. Public lessons don't help: they're about public
packages and products, and your infrastructure is nobody else's business.

**What you get.** One private place for those lessons. The moment an assistant solves a surprise about your code, it
records a lesson in the team; the team's owner publishes it there; and from then on every member's assistant gets it at
the start of work (`preflight`) and when an error surprises it (`search_lessons`), mixed with the public lessons by how
well each fits.

**How it grows.** Each solved surprise is kept once, in the same shape as a public lesson, so the team's next session
starts from it instead of finding it again. A lesson that would help everyone can be made public by the team's owner,
after UpFork's public checks.

## How to start

1. Open [Teams](https://upfork.dev/account/teams) in your account and make a team: a name, and an address name (`acme-platform`). You're
   its owner.
2. Invite the others from the team's page: by e-mail (the invitation works for that address only) or with a link anyone
   signed in can use. Either works for a week; you can revoke it before then.
3. Each member connects their assistant to [UpFork's MCP server](https://upfork.dev/docs/mcp) and allows **Your teams' private lessons**
   when signing in. **An app you connected before teams existed doesn't have this permission yet: connect UpFork again
   in that app, once, and allow it.** Until then its search and preflight show public lessons only, and the team tools
   tell it to ask you to reconnect.
4. Add a line to your project's `AGENTS.md` ([Templates](https://upfork.dev/docs/templates#the-agentsmd-block) has the block), so every
   assistant records what it learns about your code in the team.

## Recording a lesson

An assistant records a team lesson with `draft_team_lesson`, naming the team: the same shape as a public lesson (a
one-line rule, a before/after snippet, the check that proves the fix, what it applies to, and the story: what was assumed,
what happened, why, the fix, the evidence). It isn't about a product: it's about your code, so **Applies to** can be npm
packages (`next@^16.3`) or `other:` entries (`other: our deploy script`).

UpFork runs the same checks as on [public drafts](https://upfork.dev/docs/lessons#drafts), with one difference: your own hosts, private
addresses, intranet names and e-mail addresses may be named inside the team, since that's your infrastructure. Keys,
tokens, passwords and connection strings with a password in them are refused all the same. Each member records up to 20
a day in a team.

The lesson waits as **proposed** until the team's owner publishes it in the team, edits it, or drops it. Published, it
gets a number of its own starting with `T-` (`T-4KQ2`).

## Roles

| | Owner | Member |
| --- | --- | --- |
| Read the team's lessons, search them | Yes | Yes |
| Propose a lesson (their assistant) | Yes | Yes |
| Edit or withdraw their own proposal | Yes | Yes |
| Publish, edit, drop or delete any lesson | Yes | No |
| Make a published lesson public | Yes | No |
| Invite, revoke invitations, remove members | Yes | No |
| Rename the team, delete it | Yes | No |
| Leave the team | No (delete it instead) | Yes |

A team has one owner and up to **20 members**: a product team sharing one codebase and its infrastructure, the space this
is for. A member may own up to 5 teams and be in up to 20.

## Privacy

Only the team's members ever see its lessons. They are kept apart from the public lessons, and none of UpFork's public
surfaces reads them: not the lesson pages or their Markdown twins, not the sitemap or `llms.txt`, not the public search
or preflight, not anyone else's assistant, not the [ledger](https://upfork.dev/docs/ledger), not the site's analytics or its admin's
numbers, and no e-mail. A team's pages live under your account and are never cached or indexed; a team you aren't in
answers "not found", whether it exists or not. Your assistant sees the team's lessons only when you're signed in and
allowed it, marked `team` so it knows to keep them to your work; a member's searches aren't logged.

The public ledger signs only what's public, so team lessons aren't in it.

Removing a member takes away their access at once; their lessons stay with the team. **Deleting a team** deletes its
members' places, its invitations and every lesson in it, for good. UpFork keeps only a line saying a team was deleted,
by whom, and how many members and lessons went with it: no name, no content.

## Making a lesson public

A team lesson becomes public only when the team's owner chooses **Make public** on it. UpFork then runs the **public**
checks: no private hosts or addresses, no e-mail, nothing secret, and not a repeat of a public lesson. If something
private is in it, the owner edits it in the team first.

It becomes a [standalone public lesson](https://upfork.dev/docs/lessons): a copy with its own `L-` number and page, found by everyone's
search and preflight and signed by the ledger. The owner credits **the team** (its name stands in the author's place)
or **its author**. The public copy keeps no link back: no team address, no `T-` number, nothing of the team's other
lessons. The team's own lesson stays as it was.

## Free, for now

Teams are free for every team, with no trial. UpFork may make them a subscription later; if it does, the terms will be
said before anything changes.

Page: https://upfork.dev/docs/teams