by Moss (YC F25)
Sub-10ms semantic search runtime for AI agents and voice apps
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.
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 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.
pip install moss # or: npm install @moss-js/moss
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.
The permissions this connector asks for, as its own documentation states them.
5 actions an agent can call. Open one for its parameters and an example.
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
| Parameter | Type | Needed | Description |
|---|---|---|---|
| indexName | string | Required | Unique name for the index within the project. |
| documents | array | Required | Document objects, each with an id (string), text (string) and optional metadata object. |
| options | object | Optional | Accepts modelId: 'moss-minilm' (default) or 'moss-mediumlm' for higher accuracy. |
Returns
| Field | Type | Description |
|---|---|---|
| void | void | Resolves when the index has been created and uploaded to Moss Cloud. |
Example call
await client.loadIndex('faqs')Parameters
| Parameter | Type | Needed | Description |
|---|---|---|---|
| indexName | string | Required | Name of the index to load from Moss Cloud into local memory. |
Returns
| Field | Type | Description |
|---|---|---|
| void | void | Resolves when the index is loaded in memory and ready to serve queries. |
Example call
const results = await client.query('faqs', 'How do I return a damaged product?', { topK: 3 })
console.log(results.docs[0])Parameters
| Parameter | Type | Needed | Description |
|---|---|---|---|
| indexName | string | Required | Index to search. Load it first with loadIndex(). |
| queryText | string | Required | Natural-language query to embed and search. |
| options | object | Optional | Accepts topK (number of results); the Python SDK also takes alpha, 0.0 for keyword to 1.0 for semantic. |
Returns
| Field | Type | Description |
|---|---|---|
| results | object | Result object whose docs array holds matches, each with id, text and a 0 to 1 relevance score. |
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
| Parameter | Type | Needed | Description |
|---|---|---|---|
| indexName | string | Required | Name of the existing index to append documents to. |
| documents | array | Required | Array of document objects, each with an id (string) and text (string). Ids must be unique within the index. |
Returns
| Field | Type | Description |
|---|---|---|
| void | void | Resolves when the documents are indexed and the updated index is synced to Moss Cloud. |
Example call
const indexes = await client.listIndexes()
for (const idx of indexes) {
console.log(idx.name, idx.docCount, idx.status)
}Returns
| Field | Type | Description |
|---|---|---|
| indexes | array | Array of index metadata objects, each with name (string), documentCount (number), and createdAt (string ISO-8601 timestamp). |
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.
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.
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.
The nearest AI agent skills on Hokai for the same job.
| Skill | Works with | Connects by | Checked |
|---|---|---|---|
| Claude | REST API | 26 Oct | |
| -- | MCP | 17 Nov | |
| Claude · Cursor | MCP | 26 Oct | |
| Claude · Cursor | REST API | 11 Oct |
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.
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.
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.
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.
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.
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.
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.
Protocol, authentication, permissions and the call contracts on this page are read from Moss (YC F25)'s own documentation. The verdict is Hokai's reading of them, not the maintainer's claim.