by Moss (YC F25)

Moss pricing, free plan and limits

Sub-10ms semantic search runtime for AI agents and voice apps

Best for
Voice AI engineer
Not for
ML team running very large vector indexes needing multi-region replication
  • Web search
  • Memory

Should you use Moss?

Moss, a Y Combinator-backed runtime, keeps search indexes in your app so agents skip the network hop. Install with pip install moss or npm install @moss-js/moss. Newer products are Moss Inference, in private beta, and Founding Agent, a voice agent for company websites.

Sub-10ms retrieval in-browser or on-device via WebAssembly, with zero backend infrastructure required.

The in-process runtime architecture creates a genuine performance advantage over network-based vector DBs, but the moat is thin: any well-engineered local HNSW library could replicate the latency. The real moat is the Moss Cloud distribution layer and SDK convenience, not the algorithm.

Also for

  • Frontend AI developer
  • Startup founding engineer
Show 4 more
  • Voice AI developers building Vapi, LiveKit, Pipecat, or ElevenLabs agents who need retrieval latency under 10ms
  • Frontend engineers adding AI search to browser-based apps without a backend vector database
  • Python or Node.js developers replacing a Pinecone or Qdrant call in an existing RAG pipeline to cut latency and cost
  • Startup teams at the prototyping stage who need a working retrieval layer without provisioning database infrastructure

Main trade-off

The product remains early-stage relative to established vector databases: production reliability and support quality beyond the Enterprise tier are still largely unproven, and usage-based overage costs are not fully itemized.

Moss pricing

Moss lists four plans on its pricing page, each with usage costs added on top. Developer is $0 per month with $5 of monthly credits, 500 MB of storage, 60 session minutes, one project, three indexes and Discord support. Hobbyist is $30 per month and adds 2 GB of storage, 250 session minutes, unlimited projects and indexes, the standard sync engine and 3 concurrent sessions. Start-Up is $200 per month with 10 GB of storage, 1,500 session minutes, 100 concurrent sessions, Hot Path Cloud Search and email support. Enterprise is custom-priced and adds a dedicated sync engine, 99.9% SLA, single sign-on, 24/7 shared Slack support, SOC 2, HIPAA and data residency or VPC options. Pay-as-you-go rates are $1.50 per GB-month for storage, $0.03 per MB ingested, $0.09 per GB of egress and $0.05 per session minute; local queries are never metered. Moss Inference, still in private beta, is billed separately at $0.25 per million input tokens, $1.75 per million output tokens and $0.50 per 1,000 retrievals. Compare cost against Algolia or SearchApi if the job is hosted search rather than in-process retrieval.

Billing model
Freemium

Install Moss

pip install moss  # or: npm install @moss-js/moss

Before you start

  • Node.js 20.4+ or Python 3.10+, depending on the SDK
  • Create a project and API key in the Moss Portal and set MOSS_PROJECT_ID and MOSS_PROJECT_KEY
  • Create and load an index before querying it

How to invoke it

Developers call SDK methods directly in application code: client.createIndex(), client.loadIndex(), client.query(), and client.addDocuments(). Queries run locally in-process after the index is loaded from Moss Cloud. Moss ships an official MCP server package (@moss-tools/mcp-server) that exposes index management as Model Context Protocol tools for Claude Desktop, Cursor, and VS Code.

Works with

  • LangChain
  • DSPy
  • Vercel AI SDK
  • Pipecat
  • LiveKit
  • VAPI
  • ElevenLabs
  • VitePress
  • Next.js
  • Claude Desktop (via official MCP server)
  • Any LLM with function-calling support

Required runtime

  • Node.js 20.4+ (for @moss-js/moss)
  • Python 3.10+ (for moss)
  • Moss Portal project ID and API key (free Developer plan)

Where it runs

  • Web
  • Desktop
  • API

Data it can reach

  • custom document collections
  • vector indexes
  • text content with metadata
  • hybrid semantic and keyword search results

The permissions this connector asks for, as its own documentation states them.

What Moss can do

5 actions an agent can call. Open one for its parameters and an example.

Create IndexCreates a new semantic search index from an array of documents and optionally specifies an embedding model.

Example call

import { MossClient } from '@moss-js/moss'

const client = new MossClient(process.env.MOSS_PROJECT_ID!, process.env.MOSS_PROJECT_KEY!)

await client.createIndex('faqs', [
  { id: 'doc1', text: 'What is your return policy? We offer a 30-day return policy for most items.', metadata: { category: 'returns' } },
  { id: 'doc2', text: 'How do I track my order? Log into your account.', metadata: { category: 'shipping' } }
], { modelId: 'moss-minilm' })

Parameters

ParameterTypeNeededDescription
indexNamestringRequiredUnique name for the index within the project.
documentsarrayRequiredDocument objects, each with an id (string), text (string) and optional metadata object.
optionsobjectOptionalAccepts modelId: 'moss-minilm' (default) or 'moss-mediumlm' for higher accuracy.

Returns

FieldTypeDescription
voidvoidResolves when the index has been created and uploaded to Moss Cloud.
Load IndexDownloads a pre-built index from Moss Cloud into the local runtime memory, enabling sub-10ms queries without further network calls.

Example call

await client.loadIndex('faqs')

Parameters

ParameterTypeNeededDescription
indexNamestringRequiredName of the index to load from Moss Cloud into local memory.

Returns

FieldTypeDescription
voidvoidResolves when the index is loaded in memory and ready to serve queries.
QueryPerforms a semantic search on a loaded index and returns the top-k most relevant documents, with optional hybrid keyword scoring.

Example call

const results = await client.query('faqs', 'How do I return a damaged product?', { topK: 3 })
console.log(results.docs[0])

Parameters

ParameterTypeNeededDescription
indexNamestringRequiredIndex to search. Load it first with loadIndex().
queryTextstringRequiredNatural-language query to embed and search.
optionsobjectOptionalAccepts topK (number of results); the Python SDK also takes alpha, 0.0 for keyword to 1.0 for semantic.

Returns

FieldTypeDescription
resultsobjectResult object whose docs array holds matches, each with id, text and a 0 to 1 relevance score.
Add DocumentsAdds or upserts documents in an existing index (addDocs in JavaScript, add_docs in Python).

Example call

await client.addDocs('faqs', [
  { id: 'doc3', text: 'Gift wrapping is available at checkout.' },
  { id: 'doc1', text: 'Updated return policy text.' }
], { upsert: true })

Parameters

ParameterTypeNeededDescription
indexNamestringRequiredName of the existing index to append documents to.
documentsarrayRequiredArray of document objects, each with an id (string) and text (string). Ids must be unique within the index.

Returns

FieldTypeDescription
voidvoidResolves when the documents are indexed and the updated index is synced to Moss Cloud.
List IndexesReturns the names and metadata of all indexes in the current Moss Cloud project.

Example call

const indexes = await client.listIndexes()

for (const idx of indexes) {
  console.log(idx.name, idx.docCount, idx.status)
}

Returns

FieldTypeDescription
indexesarrayArray of index metadata objects, each with name (string), documentCount (number), and createdAt (string ISO-8601 timestamp).

What Moss is for

Moss is a retrieval SDK for voice agents and copilots that loads an index into application memory and answers queries in-process. On the vendor benchmark of 100,000 documents, median latency was 3.1 ms. It ships Python and JavaScript packages, with a free Developer plan and three plans above it.

  • In-process retrieval

    After an index loads into memory, queries run inside your application with no network call; the vendor reports single-digit-millisecond median and P99 figures on its own benchmark.

  • No separate vector database

    Moss Cloud stores and distributes the index as one artifact, and the SDK loads it, so there is no Pinecone, Qdrant or Weaviate cluster to run.

  • Runs where the agent runs

    One retrieval layer serves server, edge, mobile and in-browser agents, with documented builds for Python, Node, Swift, Android, Elixir and C.

  • Hybrid search with one dial

    A single alpha value from 0.0 (pure keyword) to 1.0 (pure semantic) blends both scores, and metadata filters narrow results by document attributes.

Show all 8 features
  • Built-in embedding models

    The default model is moss-minilm, with moss-mediumlm for higher accuracy, and you can supply your own vectors instead.

  • Unmetered local queries

    Queries against a loaded index are never metered on any plan; billing covers storage, ingest, egress and session minutes.

  • Enterprise compliance tier

    SOC 2 and HIPAA are listed on the Enterprise plan, alongside single sign-on, a 99.9% SLA and data residency or VPC deployment.

  • MCP server and Inference API

    An official MCP server exposes index tools to AI clients, and Moss Inference (private beta) answers chat completions from your indexes in OpenAI-compatible form.

What people use it for

  • Voice Agent FAQ Retrieval

    A voice agent calls client.query() to retrieve the top 3 matching FAQ answers in under 5ms, keeping the conversation flowing without a perceptible pause between the user question and the spoken response.

  • Offline Browser Copilot

    A JavaScript copilot loads the Moss WebAssembly runtime and a pre-built index, then serves semantic search entirely in the browser with no backend server, enabling privacy-first or air-gapped AI assistants.

  • Real-Time Customer Support Agent

    A support copilot indexes product documentation and queries Moss for relevant passages with each user message, cutting token usage by 70-90% compared to sending full documents to the LLM context window.

  • On-Device Mobile AI Search

    A mobile app bundles the Moss index and runtime on the device, giving users instant semantic search over personal notes or knowledge bases without a network connection.

  • RAG Pipeline Latency Reduction

    Teams migrating from Pinecone or Qdrant replace the external vector DB call with a local Moss runtime call, reducing retrieval latency from 80-300ms round trips down to 3-5ms while also cutting API costs.

Strengths and limits

Strengths

  • Retrieval that finishes in single-digit milliseconds on the vendor benchmark keeps voice-agent turns from stalling.
  • The browser and on-device builds let an assistant search offline, which suits privacy-sensitive or air-gapped apps.
  • Local queries are unmetered, so heavy query volume does not raise the bill; costs follow storage, ingest and session minutes.
  • SDKs for seven platforms and ten listed integrations cover most agent and voice stacks without custom glue.

Limits

  • The Developer plan caps you at one project, three indexes and 500 MB of storage, so real workloads usually need a paid plan.
  • Support is Discord only on Developer and Hobbyist, email on Start-Up, and a shared Slack channel on Enterprise.
  • Indexes live in application memory, which constrains very large corpora and low-RAM devices.
  • The Node package moved from @moss-dev/moss to @moss-js/moss, and old versions below 1.9.0 will stop loading models, so older tutorials may break.
  • Latency figures come from the vendor's own benchmark on one machine, and no independent comparison was found.

Moss alternatives

The nearest AI agent skills on Hokai for the same job.

SkillWorks withConnects byChecked
Moss This pageClaudeREST API26 Oct
ClaimGateFact-check a claim against live web sources, with quoted evidence--MCP17 Nov
Find Twitter InfluencersFind, score, and enrich Twitter/X influencers for any brand in minutesClaude · CursorMCP26 Oct
Jina Search Foundation APIRead any URL, search the web, embed and rerank: four HTTP endpoints for retrieval agents.Claude · CursorREST API11 Oct

Moss facts

Protocol
REST
Authentication
API key
Latency class
Real-time
Open source
No
Maintainer founded
2024
Headquarters
San Francisco, USA
Total funding
Y Combinator (F25 batch)

What changed

  • New feature In-Browser WebAssembly Runtime Released (1.1) source
  • Release Moss Launches in Y Combinator F25 Batch (1.0) source

Questions about Moss

What does Moss do, and who is it built for?

Moss is a semantic search runtime for teams building voice agents, copilots and in-app search. Moss Cloud stores an index, the SDK loads it into memory, and each query then runs locally. The product pages target latency-sensitive uses such as phone agents, where a slow retrieval step is audible to the caller.

Is Moss free to use?

Yes, up to a point. The Developer plan costs nothing per month and includes $5 of credits, three indexes and unlimited local queries. Heavier use moves you to Hobbyist, Start-Up or a custom Enterprise contract, with pay-as-you-go rates for storage, ingest and session minutes beyond each allowance.

Which frameworks and voice platforms does Moss work with?

The integrations page lists LangChain, DSPy, the Vercel AI SDK, LiveKit, Pipecat, Vapi, ElevenLabs, Next.js and VitePress. An MCP server package, @moss-tools/mcp-server, connects it to Claude Desktop, Cursor and VS Code, and the docs describe Python, JavaScript, browser, Swift, Android, Elixir and C SDKs.

Is the Moss source code open?

Partly. The GitHub repository at usemoss/moss is public and most of it is under the BSD 2-Clause licence, but the README says the SDKs are moving to the PolyForm Shield 1.0.0 licence, which restricts competing use and is not an OSI open source licence. Moss Cloud, the hosted ingestion layer, is a commercial service.

When would I pick Pinecone instead of Moss?

Choose a managed vector database when the corpus is too big for memory, when many services share one index, or when you need multi-region replication. Moss fits better when one agent process owns its knowledge base and retrieval time is the bottleneck. Its latency claims come from its own benchmark, so test on your data.

About Moss

Moss is a semantic search runtime from Sri Raghu Malireddi and Harsha Nalluru (Y Combinator F25, San Francisco, founded 2024, operating as InferEdge Inc.). It is a retrieval library embedded inside your own application, not a standalone vector database: queries run in-process, with no network round trip to an outside service once an index is loaded. Teams building real-time agents choose it for that reason, because retrieval sits on the critical path of every spoken turn.

Read the full background

The architecture has two layers. Moss Cloud handles ingestion, embedding, storage and distribution of an index. You create a project in the Moss Portal, copy the project ID, create an API key, and pass both to the SDK. At startup the runtime downloads the index, holds it in memory and answers every query locally. In the vendor's own benchmark (100,000 documents, Apple M4 Pro, 750 measured queries, top_k of 5) median latency was 3.1 milliseconds and P99 was 5.4 milliseconds, against a median of 351.8 to 597.6 milliseconds for ChromaDB, Qdrant and Pinecone. Moss publishes the script on GitHub, but the comparison is the vendor's own run and not an independent test.

Installation changed in 2026. The Python package is moss and the Node package is @moss-js/moss; the older @moss-dev/moss is frozen at 1.7.1, and the docs warn that versions below 1.9.0 stop loading models once the legacy download path is retired. The documentation lists SDKs for Python, JavaScript and TypeScript, a browser build, Swift, Android, Elixir and C, plus an official MCP server, @moss-tools/mcp-server, for Claude Desktop, Cursor and VS Code. Listed integrations span agent frameworks such as LangChain and DSPy, voice platforms such as Vapi and ElevenLabs, and web frameworks. The changelog shows releases as recent as 2026-10-23.

Two newer products sit beside the SDK. Moss Inference is a hosted chat-completions API in OpenAI's request shape that answers from your indexes; the vendor marks it as a private beta. Founding Agent is a voice agent for a company's own website that answers visitors, qualifies buyers and books meetings. Both are separate from the local-retrieval runtime described here.

Where the alternatives win: a managed vector store such as those in our retrieval infrastructure guide suits corpora too large to hold in memory, multi-region replication and shared access across many services. Hosted search APIs such as Exa, Tavily and Linkup fetch live web results, which Moss does not do. If you need agent memory that learns from conversations rather than a static knowledge base, compare Mem0 and Letta. For a wider view of the voice side, see our voice assistant guide or a platform such as Retell AI, and for wiring retrieval into an agent, LlamaIndex and the agent builders roundup are the usual next stops.

Sources and guides

More Agent Skills on Hokai

  • SearchApiLive Google and dozens of other search engines as JSON, one GET call per query.
  • Orthogonal Find LeadsGive AI agents instant B2B lead discovery via a single API key.