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

# Teams

> Share one context across a team — by promotion, never by pooling.

A team shares **one context** the same way your own tools already do: what one
teammate's tool learns, every teammate's tools can draw on. The team context is a
**separate, shared store** that members copy selected learnings into — it is never
a merge of anyone's personal context.

<Note>
  **Promote, don't pool.** Joining a team never exposes your private context. Your
  tools keep saving to your **personal** store; an entry only reaches the team when
  you explicitly **promote** it.
</Note>

## Create a team and invite your teammates

In the OneLamp app, use the **team switcher** in the sidebar:

1. **Create team** — name it; you become its owner. "Personal" stays the default
   context until you switch.
2. **Settings → Invite by email** — invite teammates as `member` or `admin`. They
   get an email link that drops them straight into the team.
3. Switch the active context any time between **Personal** and any team you belong to.

Free includes **1 team**; Pro lifts it to **unlimited**. See [pricing](https://onelamp.ai/pricing).

## Promote a learning

Promotion is the one place a personal learning crosses into the shared store. It is
always **explicit** — there is no automatic copy.

Promotion is a **web action** in the OneLamp app's Teams UI — there is no chat
tool for it. On the **Library** page, use **Promote to \<team>** on any row
(find the entry the way your tools do, via `get_context` / `list_context`) — or
bulk-promote a whole filtered set. Categories like *Projects* / *Work* / *People*
are nudged as team-worthy; *Preferences* / *Style* stay personal by default.

What happens on promote:

* **Secrets are redacted** at the boundary — API keys, tokens, and `.env`-style
  values are scrubbed before the learning reaches the team.
* You're recorded as the **contributor**. If two teammates promote the same (or a
  similar) learning, it dedupes to one entry and credits both.
* It enters the **trust gate** (below) — live immediately, but `unverified` until a
  teammate independently corroborates it, and never silently overwriting a conflict.

## Trust & corroboration

The same mechanism that makes the good case great — one teammate teaches, everyone's
tools learn — could let one *incorrect* fix propagate just as fast. So a promoted
learning has to **earn its standing**. Every team entry carries a trust state:

| Trust        | Means                                 | How it gets there                                        |
| ------------ | ------------------------------------- | -------------------------------------------------------- |
| `unverified` | one member's learning, uncorroborated | a lone promotion                                         |
| `verified`   | independently corroborated            | a 2nd teammate promotes the **same or a similar** lesson |
| `contested`  | a similar entry **contradicts** it    | a promotion lands similar-but-opposite                   |

OneLamp decides this at promote time: it finds the nearest existing team learnings
and, when one is close, classifies whether the new promotion **agrees** (corroborate
→ trust rises) or **contradicts** (both flip to `contested`). A contradiction is
**never** allowed to silently overwrite the other side — instead both are frozen and
surface in the team's **Needs review** list, where an owner/admin keeps one, removes
one, or dismisses the conflict. (This judgment is the one model call on the path, run
at promote time; retrieval stays generation-free.)

## Retrieve across scopes

`get_context` takes an optional **`scope`** so a tool can read from your personal
store, a team's store, or both:

| `scope`           | Reads from                           |
| ----------------- | ------------------------------------ |
| `personal`        | Your own store only                  |
| `team`            | Every team you belong to             |
| `team:<id>`       | One specific team (must be a member) |
| `all` *(default)* | Personal **+** your teams, fused     |

When more than one store is in scope, OneLamp **fuses** each store's ranked results
with a final scope-weighted Reciprocal Rank Fusion — **personal context wins ties**.
This is pure rank math in the Worker: still **retrieval, never generation**. Every
returned chunk carries a `scope` marker (`personal` / `team:<id>`), the
`contributed_by` member, and its `trust` — so the tool (and you) can see provenance.

Team results are also **trust-weighted**: `verified` learnings rank above
`unverified` above `contested` (which is surfaced with a ⚠). By default everything is
returned (so a brand-new team isn't empty); pass **`verified_only: true`** for
high-stakes reads to drop anything not yet corroborated. Your personal context is
always included.

## Provenance, governance & privacy

* **Who taught what** — the team view groups the shared context by contributor and
  category, so the team can see exactly what each member taught OneLamp.
* **Curation** — owners and admins can resolve **contested** pairs (keep one, remove
  one, or dismiss), **prune** any team entry (it's removed for everyone), and
  **export** the whole team context as portable JSON. Members can promote and read,
  but not prune or resolve.
* **Privacy invariants** — joining a team never exposes your un-promoted entries;
  promotion is opt-in, redacted, and reversible; the team owns its data, the same
  way you own yours.

<Note>
  For exact parameters and return shapes, see the
  [context tools reference](/tools/context).
</Note>