Short answers to what developers, security reviewers and agents ask before integrating Mnemo. Each answer links to the exact contract; the Docs and the Agent Protocol hold the technical depth.
Technical depth: Docs · Agent Protocol · OpenAPI · Pricing
Whether a vector you hold resolves to an object registered to your own Mnemo account or namespace. Embed registers your vector and returns a watermarked copy plus a vector_uid; verify later checks whether a presented vector resolves to one of those registered objects and returns its vector_uid.
That is what provenance means here: the vector was issued by your own pipeline and is still attributable to it. It is a narrower question than similarity. See how it works.
Mnemo does not establish whether content is true, who authored or owns it, whether a file or document is authentic, or which model produced a vector. It does not inspect content, so it does not detect prompt injection or moderate anything.
It is not a vector database and does not do similarity search. Verification is scoped to your own objects: it cannot tell you whether a vector belongs to someone else, and verified=false is not proof that a vector is foreign.
No. Your model keeps producing vectors and your store keeps holding them. You add two calls: on insert, send the vector and a model_id label to embed and store the returned watermarked_vector instead of the original; on retrieval, send the vector you read back to verify and act on verified.
The watermarked vector is a plain array of numbers with the same number of dimensions. No native connectors: any store that returns it unchanged works. Setup: Python SDK, API reference.
It is meant to be used in place of the original, for storage and for search. It is a unit-length copy of your input with the same number of dimensions, measurably perturbed to carry the identity.
Similarity scores computed with it differ from scores computed with the original, so re-check any thresholds you tuned on the originals. The vector contract is in the Agent Protocol.
Only after you embed them through Mnemo. There is no retroactive coverage: a vector that was never registered to your account or namespace comes back verified=false. To cover an existing corpus, send each vector through embed and store the watermarked copies it returns.
Verification is tenant-scoped: verify only resolves to objects registered to your own account or namespace, and never attributes a vector to another tenant. You cannot check another party's vectors.
Vectors of 512 to 4096 finite numbers. Send the FP32 values your model produced; unit-norm input is expected, and Mnemo L2-normalizes what it receives before watermarking.
model_id is a label you declare, for example text-embedding-3-small; Mnemo does not run or attest the model. The exact schema is in openapi.json.
A normal 200 with verified=false and no vector_uid: attribution to one of your registered objects could not be shown, because the vector was never embedded through Mnemo, was changed too much after embedding, or its retention has ended. It is not an error and not proof that the vector is foreign; your code decides what to do, for example exclude the result.
Decide on verified, not confidence. A verification Mnemo cannot complete is never a result: it answers 503, costs nothing and can be retried.
Yes. The API is plain HTTPS at https://api.trymnemo.com: POST /v1/embed and POST /v1/verify with your key in X-API-Key, as described in openapi.json and the API reference.
The Python SDK (pip install mnemo-protocol, from mnemo_sdk import MnemoClient) covers embed and verify for account API keys. Lineage and the accountless agent path are not in the SDK; call them over HTTP.
When you embed a derived vector, name its parent: the parent's vector_uid, a relation (chunk, summary, translation, re_embed or transform) and the parent's watermarked vector. Mnemo verifies that the parent is yours before it creates the child.
GET /v1/lineage/{vector_uid} returns the chain and re-verifies every link on each read. Lineage records which parent you named, not what the transformation did or whether it was faithful. Reads are free. Details: Agent Protocol.
Teams use an API key on a monthly plan with an included verification allowance, after a 30-day free trial that includes 10,000 verifications. Embedding is never billed per call. There is no automatic overage: at the allowance, verification pauses until the next billing period, and API-key calls never use machine payments.
Agents without an account pay $0.01 per verification or $5 for 500. A healthy result, positive or negative, counts as one verification; one Mnemo fails to complete costs nothing. Plans: Pricing.
Yes. One unauthenticated call creates a short-lived namespace and returns a capability token, shown once; with it the agent embeds, verifies and reads lineage. No sign-up, API key or person is needed. A namespace lasts 24 hours by default and 72 hours at most.
Creating a namespace, embedding and lineage reads are free; each verification is paid. There is no public MCP server today (MCP support is planned): agents use the HTTP API. Start with the Agent Protocol, llms.txt or the agents page.
Verify answers HTTP 402 with a payment challenge; the agent pays it and resends the identical request. Live rails: x402 with USDC on Base, and MPP with USDC.e on Tempo, each at $0.01 per verification.
A namespace can instead fund 500 verifications for $5 with x402, Tempo, or a card through MPP and a Stripe Shared Payment Token. A card cannot buy a single $0.01 verification. The namespace's payment_menu lists what it can buy right now.
Its capability stops working and its data is purged; nothing is kept. Activity does not extend a namespace. One funded with the 500-verification burst stays usable for its 14-day window; for 24 hours after that its data is kept and a refill reopens it.
To keep the data, a signed-in person can promote the namespace to a permanent account with the same vector_uids and lineage; the account's plan retention then applies. Promotion needs that person's session: an agent cannot promote on its own.
The vector and the model_id label you send, plus any optional metadata you attach; never your documents or text. Mnemo keeps each registered object, with its provenance and lineage records, for as long as it must stay verifiable: your plan's retention, or until an accountless namespace expires. Your own storage stays yours.
Customer Content is not sold and not used to train models without your authorization. Details: Privacy Policy and DPA.
Yes, website and product analytics through the providers listed on Subprocessors. The implementation is designed not to send passwords, API keys, authorization credentials, request or response bodies, payment credentials, wallet secrets or Customer Content to analytics providers.
What is collected, and for how long, is described in the Privacy Policy.
Technical: the Agent Protocol is the complete wire contract, openapi.json the machine-readable schema, llms.txt the orientation for agents, and the Python SDK docs the account path.
Legal: Terms of Service, Privacy Policy, DPA and Subprocessors. Accountless access, on any payment rail, must not be used for personal data subject to EEA, UK or Swiss data protection law.
The Docs hold the technical depth and the Agent Protocol is the complete contract. For pilots and integration help, request a pilot.