Everyone re-derives context
Each person and each CI run reads the same repo from scratch. The work is never shared, and you pay for it every time.
For teams
One context plane for every dev and agent.
LeanCTX gives your team a shared, audited context plane: consistent compressed reads, pooled memory across people and CI agents, and per-role budgets, so every agent works from the same context and you can see what it cost.
The cost
What every team pays twice for.
Without a shared layer, every developer and CI agent rebuilds the same context alone.
Memory lives in one session
Decisions and findings stay trapped in one developer's chat. The next agent starts blind.
No budget, no audit
You can't cap what a role spends, and you can't show anyone what your agents actually read.
From solo builders to regulated fleets.
How it works
How the shared plane works.
One command turns the local engine into a server your whole team and its CI agents query: read-first, role-scoped and audited.
One server fronts every repo
LeanCTX team serve runs one process over many workspaces. Everyone points their MCP client at its URL and queries one shared BM25, graph and artifact index instead of each clone rebuilding its own.
Tokens carry roles and scopes
Access is per token, stored as a SHA-256 hash, never plaintext. Roles (viewer, member, admin, owner) expand to scopes like search, graph and knowledge, least-privilege by default.
Read-first by design
The shared surface authorizes search, graph, knowledge, events and artifacts, and denies code-mutating tools. A shared server hands out context, not remote shells.
Every access is audited
Each decision is written to an append-only audit log, with a live event stream of what agents read and did across the team.
See it run
Stand up a shared plane in minutes.
One config file lists your repos and tokens. Self-host it, or let us provision a managed server when you start the Team plan.
terminal
# Run one shared server in front of your repos
$ lean-ctx team serve --config team.json# Mint a role-scoped token per teammate (only the hash is stored)
$ lean-ctx team token create --config team.json --id alice --role member# Give the CI bot read-only search and graph, nothing else
$ lean-ctx team token create --config team.json --id ci-bot --scopes search,graph# Keep the shared index fresh on a timer
$ lean-ctx team sync --config team.jsonWhat you get
What changes for the team.
Four outcomes once context is shared instead of rebuilt by everyone, every time.
Read the repo once
The shared index is built once and reused by every developer and CI agent, with no parallel re-derivation.
Knowledge compounds
Findings and decisions persist across people and runs, so the team's memory grows instead of resetting each session.
Predictable, capped cost
Per-role token budgets keep spend in bounds, and the ledger proves where every token went.
Provable and ownable
An append-only audit log answers what agents touched, and the server is self-hostable under Apache-2.0.
Local stays free forever; Team adds the shared plane on top. Regulated or air-gapped? See LeanCTX for enterprise or compare the plans.
Teams, answered.
Pro syncs your own context across your devices. Team adds a shared, audited context plane for the whole team and its CI agents, with role-based access and budgets.
Yes. CI agents query the same shared plane as developers, so automated runs reuse pooled memory and stay within role budgets.
Each role (viewer, member, admin, owner) gets a token budget. Spend is metered into the same signed ledger that powers savings reports, so limits are provable, not guessed.
Your repositories stay on your hosts. The plane shares compressed context and metadata, not your source tree, and the pricing page lists exactly what syncs.
Find your fit.
Choose the LeanCTX path that matches how you build.
Give your team one context plane.
One shared, audited layer for every developer and agent. Start on the Team plan, or talk to us about a pilot.