Shelvia

The project brain for AI-native work.

Shelvia turns scattered AI work into reviewed memory your next tool can trust.

Humans approve. Tools retrieve. Agents reuse.

Request access Watch the loop
Read the docs

Nothing becomes trusted memory until reviewed.

  • ChatGPT
  • Claude
  • Cursor
  • Lovable
  • Perplexity
  • Notion
  • GitHub
HUMAN APPROVEDPROJECTBRAINChatGPTClaudeCursorLovablePerplexityNotionGitHub

Watch one captured trace become trusted memory.

One cycle, four phases. The same motion every tool, connector, and agent traces when they touch a Shelvia project.

Capture → Review → Memory → RetrievalOne cycle · ~9 seconds
01 CAPTURE02 REVIEW03 MEMORY04 RETRIEVALChatFileLinkHUMAN REVIEWDecision · ✓Source · ✓Prompt · ✓APIMCPSDK

Capture. Review. Continue. Capture back.

AI work no longer lives in one chat in one tool. The bottleneck is no longer generating answers. It is preserving trusted context so the next human or agent continues correctly.

  1. 01
    Capture work

    Import a Claude Code session, a ChatGPT thread, a Cursor diff, or a doc.

  2. 02
    Approve what matters

    Nothing becomes trusted memory until a human approves it.

  3. 03
    Continue with context

    Generate a source-backed pack so the next tool starts from what is true, not a cold start.

  4. 04
    Bring back what changed

    Paste the result back, and Shelvia updates the project brain.

One real loop

Save a Claude Code debugging session. Generate a context pack for Cursor. Cursor produces a fix. Bring the result back into Shelvia. Shelvia updates the project brain with what changed, so the next session starts from the truth, not a guess.

See the loop in the docs

Nothing becomes trusted memory until reviewed.

One reviewed memory. Seven surfaces, one loop.

Capture scattered AI work, review it into project memory, hand the right context to the next tool, and bring the result back.

01

Capture

Bring AI work in from anywhere — paste a chat, capture from the browser, or connect GitHub, Notion, and Google Drive. Everything lands in one place.

  • Chats, files, links, screenshots, and tool outputs
  • Capture is always something you click — never background collection
How work comes in

Reviewed memory humans trust. Retrievable by tools.

Human attention is limited. Project memory should reduce what you have to hold in your head. It should also stay reachable from every tool that touches the work.

  • Trust

    Review-before-save memory

    Imports, connector activity, and capture become candidates first. Nothing enters trusted project memory until a workspace member approves it.

    How review works
  • Compression

    Context packs + rolling summaries

    Decisions, sources, prompts, next steps, and open questions are ranked and packed for the next session. Older memory compresses without inventing claims.

    See the workflow
  • Ingestion

    Connectors for the sources you already use

    GitHub, Notion, and Google Drive / Docs flow through the same review queue every other write goes through. Cost guardrails and per-source state hold sync bounded.

    Connector reference
  • Retrieval

    Semantic search over reviewed memory

    Hybrid keyword + vector search across decisions, sources, prompts, candidates, and summaries. Workspace boundaries are enforced at every layer.

    Search reference
  • API + MCP

    Tools retrieve approved context

    REST API and MCP let tools request approved project context without bypassing review. Scoped tokens, audit logs, and rate limits per workspace.

    Developer reference
  • SDK

    TypeScript SDK for agent builds

    Installable from public npm: @shelvia/sdk. Typed client wrapping projects, context, semantic search, candidates, and summaries. Writes always create review candidates.

    View SDK reference
  • Events

    Signed webhooks for downstream tools

    Signed outbound delivery on candidate creation, context-pack generation, and handoffs. Retry backoff and admin test delivery from the workspace settings.

    Webhook contracts
  • Capture

    Browser Capture

    User-initiated capture from ChatGPT, Claude, Perplexity, Gemini, and NotebookLM routed through the same review queue every other write goes through.

    Read the concept

Humans approve. Tools retrieve. Agents reuse.

01

Humans approve

Imports, connector activity, and capture become review candidates first. A workspace member approves, edits, or rejects each one. Trusted memory is what survives that step.

02

Tools retrieve

Docs, API, MCP, SDK, and webhooks all read from the same trusted memory. Workspace boundaries hold at every layer; reads always carry provenance.

03

Agents reuse

External agent runtimes call Shelvia before they act, so the next session continues from approved context, not from raw chat scrollback. Shelvia remembers. Agents reuse.

Shelvia builds a reviewed project context graph — decisions, sources, prompts, tools, handoffs, and outcomes connected, so teams see where knowledge came from, how it was used, and what changed.

One reviewed memory, four ways to use it — a task-scoped pack, a decision trace, a workspace search, or the full original. You pick the strategy, and every pack states which one built it.

Not a vector dump. Not an Agent OS. Not autonomous. Structured project memory humans review before any tool sees it.

For work that cannot afford to lose its reasoning.

Different roles produce different outputs, but the shape of the problem is the same: useful context gets buried before it can become progress. Four examples below, with a full page of roles to follow.

  • Founders + product builders

    Keep the decisions that shaped the product.

    • Investor questions, positioning shifts, and user feedback stay near the reasoning that drove them.
    • Pitch drafts and the prompts that produced them stay reusable across pitches.
    • Context packs let the next session start with the project, not from scratch.
    Founder workflow
  • Developers + agent builders

    Coding sessions don't restart from zero.

    • Build notes, architecture decisions, and prompts that produced clean diffs stay in the project.
    • Tools call the memory through API, MCP, or SDK, without bypassing review.
    • Handoffs hand the next session a ranked context pack, not chat scrollback.
    Developer workflow
  • Researchers + students

    Source-first archives, not scattered citations.

    • Citations stay attached to the threads that produced them.
    • Cross-tool research synthesizes into a workspace, not a dozen chat sidebars.
    • Open questions stay open until a source closes them.
    Researcher workflow
  • Teams + product builders

    Shared memory with a real audit trail.

    • Decisions are pinned with the author, the date, and the reasoning behind them.
    • New hires onboard by reading the project, not catching up on Slack scrollback.
    • Roles control who edits, who reviews, and who shares.
    Team workflow
See every role and workflow

Return to the work with the context already connected.

Shelvia keeps decisions, sources, prompts, summaries, and next steps close to the project, so people and tools can continue from trusted memory.

Request access Read the docs

Humans approve. Tools retrieve. Agents reuse.