You don't use one AI anymore — Claude to code, ChatGPT to think, Cursor in your editor, Gemini to search. Each one quietly learns how you work, then keeps it to itself, and AI providers have no incentive to share. OneLamp is the self-curating, neutral layer across all of them: a per-user context layer every agent writes to and reads from through a single MCP endpoint. Switch tools and the new agent already knows your stack, your conventions, the decision you made an hour ago in another tab.
- Cross-provider. One endpoint that Claude, ChatGPT, Cursor, Codex, and any other MCP client share.
- Self-curating. It adapts as you work — superseding stale facts, sharpening retrieval, corroborating across agents — so it's never a file you maintain.
- Hooks into the agent loop, not just an endpoint. Beyond MCP, our plugins for Claude Code, Codex, and Cursor install secure agent lifecycle hooks — auto-loading your context when a session starts and capturing learnings before it ends — so context adherence is enforced in the loop, not left to the agent to "remember".
- Teams, by promotion not pooling. Opt in to share a learning with your team without exposing your personal context. Use preset/custom policies to control context sharing.
- Yours. Export or delete everything at any time.
- Create an account at app.onelamp.ai — sign in with email (one-time code), Google, or GitHub.
- Connect an agent — copy your MCP endpoint and add it to your AI client (below). The client runs the sign-in flow itself; there's no API key to paste.
- Use it. Your agents now auto-load context at the start of a session and save durable learnings as you work.
Your endpoint:
https://api.onelamp.ai/mcp
It's a remote, streamable-HTTP MCP server secured with OAuth 2.1 — the first connection opens a browser to sign in to OneLamp, then the client caches the token.
- Cross-agent handoff (the "aha"). Tell Claude a decision about your architecture; open Cursor an hour later and it already knows — no re-explaining.
- Your preferences travel with you. Your stack, coding conventions, and writing voice follow you into every agent, so each one sounds like you from the first message.
- Pick up where you left off. Switch tools mid-task and your current focus and open work come along — no cold start in the new agent.
- Onboard a new agent or tool instantly. Point a fresh agent at OneLamp and it starts from everything the others learned, not from zero.
- Bring your own knowledge. Connect Notion, Drive, or any MCP server and pull your specs and docs in on demand — indexed into the same context every agent draws on.
- Stop re-explaining across tools. A ranked context pack beats re-pasting the same background into every new chat (fewer tokens is the side effect, not the point).
- Share what works with your team. Promote a hard-won fix or convention to a team; once a teammate hits the same thing it's verified and everyone's agents build on it — without pooling anyone's private context.
- Own and move your context. Run
export_contextto take your entire context with you as JSON — anytime, no lock-in.
Add OneLamp as a remote HTTP MCP server:
{
"mcpServers": {
"onelamp": {
"type": "http",
"url": "https://api.onelamp.ai/mcp"
}
}
}In the Claude app, add it as a custom connector; in ChatGPT, enable developer mode and add the remote MCP server.
Install the plugin (bundles the MCP server, auto get/save session hooks, and the
/onelamp command, aliased /ol):
# add the OneLamp marketplace, then install the plugin
/plugin marketplace add https://app.onelamp.ai/marketplace.json
/plugin install onelampcurl -fsSL https://app.onelamp.ai/codex/install.sh | bashRegisters OneLamp as a native remote MCP server and wires SessionStart/Stop hooks (auto load/save, fail-open).
curl -fsSL https://app.onelamp.ai/cursor/install.sh | bashOr one-click — Add to Cursor:
cursor://anysphere.cursor-deeplink/mcp/install?name=onelamp&config=eyJ1cmwiOiJodHRwczovL2FwaS5vbmVsYW1wLmFpL21jcCJ9
Point the MCP Inspector at
https://api.onelamp.ai/mcp to confirm the OAuth flow and list the tools.
An MCP endpoint exposes the tools — but an endpoint alone can't guarantee an agent actually uses them at the right moment. OneLamp's plugins go a layer deeper. For Claude Code, Codex, and Cursor, installing the plugin securely wires session lifecycle hooks directly into the agent's loop:
- On session start, the hook loads your ranked context pack before the agent takes its first step — so it begins every task already grounded in your preferences, decisions, and conventions.
- On session end, the hook captures durable learnings back to your context — so nothing has to be remembered manually.
Because loading and capture run as part of the agent's own lifecycle rather than as optional tool calls, context adherence is enforced in the loop, not left to chance. The hooks are fail-open (a OneLamp hiccup never blocks your agent) and scoped to the lifecycle events they need — nothing more.
These three are the whole surface most agents use:
| Tool | What it does |
|---|---|
save_context |
Save a durable learning — a preference, decision, or fact — to your context. |
get_context |
Retrieve a ranked context pack for the current task (hybrid semantic + keyword + recency). |
export_context |
Export your entire context as portable JSON — you own your data. |
The Claude Code and Codex plugins call get_context at session start and
save_context before a session ends automatically, so capture and recall happen
without you thinking about it.
get_context also takes an optional scope — personal, team, team:<id>,
or all (the default) — so a query can draw on your personal context, a team's
shared context, or both fused into one ranked pack. See Teams below.
Beyond what your agents capture directly, you can connect the tools you already work in — Notion, Google Drive, Slack, or any remote MCP server. When you pull content in, OneLamp indexes it on demand and folds it into the same self-curating context layer your agents draw on — it enriches your context rather than relaying a source straight through. Connect once, then pull in fresh material whenever you want.
On-demand, not crawled. Connected sources are indexed only when you explicitly pull them in — there's no background crawl. Capture is capture-on-write (agents call
save_context); freshness for connected sources is an explicit action you take.
Manage sources from the Data sources page in the app, or with the Library tools below.
The kb_* tools manage connected sources and the compiled Library:
| Tool | What it does |
|---|---|
kb_connect_source |
Register an upstream MCP server as a source. |
kb_sync_source |
Pull a connected source's content into the Library. |
kb_list_sources / kb_disconnect_source |
List or remove connected sources. |
kb_ingest_text / kb_ingest_url |
Ingest raw text or a URL into the Library. |
kb_query |
Search the Library for relevant pages. |
kb_list_pages / kb_get_page |
Browse or fetch a compiled page. |
kb_lint |
Health-check the Library: orphan pages, dangling [[links]], thin pages. |
A team shares one context layer — but by promotion, not pooling. Your personal context is never merged into a team's. Instead, you explicitly promote a selected learning into a separate, ACL'd team store, where every teammate's agents can draw on it. Joining a team never exposes your private entries.
- Opt-in and explicit.
save_contextalways writes to your personal store. A learning reaches the team only when you callpromote_to_team(or use the Promote action in the app). - Secret-redacted at the boundary. Promotions are scrubbed of secrets on the personal→team hop and tagged with you as the contributor.
- Corroborate-or-contest trust gate. A promotion goes live as unverified until a teammate independently promotes the same lesson (then verified). A promotion that contradicts an existing team learning flags both as contested for an admin to resolve — so one wrong fix can't silently spread.
- Read with
scope.get_contextfuses your personal pack with in-scope team packs; each result is tagged with its scope, contributor, and trust state. Useverified_onlyto read only corroborated team learnings.
| Tool | What it does |
|---|---|
promote_to_team |
Share one of your saved learnings with a team's shared context (redacted, attributed). |
Members and roles are managed from the Teams area in the app.
Flat, no metering, no usage billing — OneLamp is a retrieval/indexing layer, so there's no per-request generation cost to pass through. See Pricing for current details.
| Plan | Price | For |
|---|---|---|
| Free | $0 | 2 agents, 5 data sources, share with 1 team, export anytime — no card. |
| Pro | $3/mo (or $2/mo billed annually) | Unlimited agents, data sources, and teams. |
| Enterprise | Contact sales | Everything in Pro org-wide, plus SSO/SAML, audit logs, and data residency. |
OneLamp is privacy-first by design: your context is per-user, never mixed across users, and fully exportable and deletable. Use of the hosted service is governed by the Terms of Service and Privacy Policy.
Licensed under the Apache License 2.0. "OneLamp", "Saho Labs", and the
OneLamp logo are trademarks of Saho Labs, Inc. — see NOTICE. This license
covers the docs and examples in this repository; the OneLamp product source is
proprietary and owned by Saho Labs, Inc.