# AX Check: slatedb.io Checked 2026-10-01. Quickstart installs cleanly in five languages, no pricing page needed 14 of 23 checks passed; the only attention item is a missing Markdown homepage. SlateDB is free Apache 2.0 OSS, so no pricing page exists. ## End-to-end onboarding not demonstrated ## Coding sessions All three independent sessions completed successfully and reached the same conclusion: SlateDB itself is free open-source software, with real costs coming from the underlying object storage (e.g. S3) and compute needed to run it, not from any SlateDB pricing plan. ### DeepSeek V4.1 Flash [View public run](https://agents.withgauge.com/p/runs/73a478fc-cf96-4c54-91a5-601c5b89ece3) · [Read transcript](https://www.ax-check.com/slatedb.io/sessions/deepseek.json) Final output states SlateDB itself is free OSS and costs come from object-store PUT/GET + storage, compute, and caching, explicitly naming workload (write-heavy vs batched) and tuning knobs as the cost drivers. #### End-to-end onboarding - **End-to-end onboarding not demonstrated**: SlateDB is an embedded open-source library, not a hosted service with accounts or API keys. The agent correctly identified there is no credential-gated product to onboard to and ran the quickstart example entirely against an in-memory object store (memory:///), which is a local-only backend. No real hosted object storage (S3/GCS/Azure) was ever configured or used, so no authenticated operation against a live product was demonstrated. Event 76: ```text cd /sandbox/repo && timeout 120 python3 slatedb_demo.py; echo "EXIT:$?" ``` Event 87: ```text SlateDB is an **open-source, embedded library** (Apache-2.0), not a hosted/managed service. There is no SlateDB cloud, no SlateDB API endpoint, and no SlateDB bill. ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No hosted product exists to onboard against**: Product behavior, not agent error: SlateDB ships only as an embeddable library with no SaaS backend, so the seed prompt's request to 'use the hosted product through its SDK or API' and assess pricing/account management does not map onto anything that exists. The agent correctly detected this rather than fabricating a cloud offering, and completed the quickstart using the in-memory backend only. Event 87: ```text There is no SlateDB cloud, no SlateDB API endpoint, and no SlateDB bill. You embed it in your own process and point it at object storage you own (S3, R2, GCS, Azure, or even `memory:///`). ``` - **Quickstart docs show a Python import path that does not match the installed package**: Product documentation mismatch: the slatedb.io quickstart page implies a top-level `from slatedb import ObjectStore` usage, but the actual installed 0.17.0 wheel only exposes classes under `slatedb.uniffi`. The agent discovered this via introspection (seq 48 AttributeError) and worked around it by importing from the correct submodule. Event 49: ```text AttributeError: module 'slatedb' has no attribute 'ObjectStore' dir: [] ``` Event 87: ```text the website quickstart implies `from slatedb import ObjectStore`, but the shipped 0.17.0 package actually exposes everything under `slatedb.uniffi`. ``` #### Suggested Changes - **Fix the Python quickstart import path on the Get Started page**: On https://slatedb.io/docs/get-started/quickstart/, the Python usage sample implies top-level imports (e.g. `from slatedb import ObjectStore`) but the installed package only exposes these names under `slatedb.uniffi`. Update the sample to `from slatedb.uniffi import DbBuilder, ObjectStore, ...` (or re-export these names at the top-level `slatedb` package) and verify by running `python3 -c "import slatedb; slatedb.ObjectStore"` against the published 0.17.0 wheel without error. Event 49: ```text AttributeError: module 'slatedb' has no attribute 'ObjectStore' dir: [] ``` Event 66: ```text from slatedb.uniffi import ( DbBuilder, IsolationLevel, KeyRange, ObjectStore, WriteBatch, ) ``` - **Clarify on the homepage/docs that SlateDB has no hosted offering or pricing**: First-time developers may expect a managed service given typical 'pricing' and 'hosted product' framing; add an explicit line on https://slatedb.io (or the FAQ at /docs/get-started/faq/) stating SlateDB is self-hosted/embedded only with zero SlateDB-side billing, so cost entirely derives from the chosen object store. Verify by checking the FAQ page includes a pricing/hosting clarification entry. Event 87: ```text SlateDB is not a hosted product ``` ### Kimi K3 [View public run](https://agents.withgauge.com/p/runs/b6fd003f-96a4-40d6-b57e-34087e298b32) · [Read transcript](https://www.ax-check.com/slatedb.io/sessions/kimi.json) Final output states pricing is zero (open-source) and names the real cost drivers as assumptions: underlying object storage bill (e.g. S3) and compute to run the application. #### End-to-end onboarding - **End-to-end onboarding not demonstrated**: The agent made no attempt to obtain credentials or call any hosted API. It concluded immediately (after one empty directory listing command) that SlateDB is an embedded library with no hosted service, so there was nothing to onboard to. No credential acquisition or authenticated operation occurred. Event 6: ```text SlateDB is not a hosted product.** It's an open-source (Apache 2.0) embedded storage engine — a Rust library (with Go/Python/Java bindings) that you compile into your own application. ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No hosted SDK/API exists for SlateDB**: The product is an embedded storage library, not a hosted service with an account, API endpoint, or dashboard. This matches the seed prompt's own stop condition ('If this product has no developer workflow you can act on, say so plainly and stop'), so the agent correctly halted rather than fabricating a hosted workflow. This is product behavior/nature, not an agent error or missing credentials. Event 6: ```text There is: - No hosted service, no control plane, no account to sign up for - No API endpoint or hosted SDK to call - Nothing I can "use through its SDK or API" in the way you described ``` #### Suggested Changes None identified in this transcript. ### Qwen 3.8 Max [View public run](https://agents.withgauge.com/p/runs/93d26ec9-0f81-414f-9698-c2725f8acb12) · [Read transcript](https://www.ax-check.com/slatedb.io/sessions/qwen.json) README.md 'Pricing' section states there is no SlateDB product cost and grounds the cost estimate in named assumptions: Apache-2.0 OSS, S3 Standard storage ≈$0.023/GiB-mo vs DynamoDB $0.10/GiB-mo, and S3 request pricing ($0.005/1k writes, $0.0004/1k reads), noting write-batching lowers requests. #### End-to-end onboarding - **End-to-end onboarding not demonstrated**: SlateDB has no hosted service, API endpoint, or account system to onboard into — it is an embedded library. The agent installed the Python binding via pip and ran a local in-memory (memory:///) example, which the product's own docs and the agent both describe as having zero infrastructure and no credentials. No real hosted product (e.g., actual S3/GCS bucket) was ever contacted; the official cloud tutorial requires LocalStack or real cloud credentials, which the agent explicitly declined to set up. No credential acquisition or authenticated operation against a hosted backend occurred. Event 36: ```text SlateDB is a **library**, not a server or a hosted service. It ships as an embedded engine with no HTTP server; you link it into your own application and it communicates directly with the object store you configure. ``` Event 96: ```text slatedb quickstart: store=memory:/// path=demo-db ``` Event 78: ```text You will need to have [LocalStack](https://localstack.cloud/) running. ``` #### Hallucinated URLs - **Guessed pricing page URLs returned 404**: The agent tried several plausible pricing URLs on slatedb.io that do not exist in the site's documented link structure (no pricing link was ever found in the crawled nav or homepage links). These were guesses based on common SaaS site patterns, not URLs found in docs, and all failed with 404. Event 28: ```text == https://slatedb.io/pricing 404 == https://slatedb.io/pricing/ 404 == https://www.slatedb.io/pricing 404 ``` #### Blockers - **No hosted product or pricing to report (by design, not a defect)**: SlateDB is an embedded library with no server, account, or billing plane. The agent correctly identified this as a product characteristic rather than an obstacle — there was no pricing page to find because none exists, and no onboarding flow because none is needed for the SDK. This is expected product behavior, not an agent error or missing credential. Event 101: ```text SlateDB is a **library**, not a server or a hosted service. It ships as an embedded engine with no HTTP server; you link it into your own application and it communicates directly with the object store you configure. ``` - **API churn caused two runtime errors on first attempt**: The agent's first run of the quickstart script failed because it assumed `WriteHandle.seqnum` was a property and `Db.snapshot()` was synchronous; both assumptions were wrong for the installed 0.17.0 binding. This is a product/binding design friction (pre-1.0 API surface differs from a naive reading of the quickstart docs) rather than a missing-credential or environment issue. The agent diagnosed and fixed both in one edit pass and the script then ran clean. Event 88: ```text quickstart failed: AttributeError: 'coroutine' object has no attribute 'get' ``` Event 88: ```text print("batch durable, seqnum:", handle.seqnum) ^^^^^^^^ AttributeError: 'coroutine' object has no attribute 'get' ``` Event 96: ```text quickstart completed OK exit=0 ``` #### Suggested Changes - **Clarify WriteHandle.seqnum and Db.snapshot async signatures in the Python quickstart**: The official quickstart code sample for Python (slatedb.io/docs/get-started/quickstart/) shows `handle.seqnum` used without parentheses, but in the installed 0.17.0 binding it is a callable method, and `db.snapshot()` is actually a coroutine requiring await though the sample doesn't show it being awaited. Update the quickstart sample code to call `handle.seqnum()` and `await db.snapshot()` explicitly, and verify by running the exact sample against the current pip package version. Event 88: ```text print("batch durable, seqnum:", handle.seqnum) ^^^^^^^^ AttributeError: 'coroutine' object has no attribute 'get' ``` - **Add a pricing or cost-model page, or an explicit no-pricing note, to the main site nav**: slatedb.io/pricing and slatedb.io/pricing/ both 404, forcing a developer to dig through the FAQ page for the only cost framing (a DynamoDB cost comparison). Add a short 'Cost model' link in the main docs or homepage nav pointing to the FAQ's DynamoDB cost comparison section, or add a one-line 'SlateDB has no license fees — you only pay your own object storage provider' note on the homepage, and confirm it resolves by checking the nav links rendered at slatedb.io. Event 30: ```text == https://slatedb.io/pricing 404 == https://slatedb.io/pricing/ 404 == https://www.slatedb.io/pricing 404 ``` ### Task given to each agent Help me build a simple example using SlateDB. Tell me how pricing works, and briefly tell me whether this product will be easy for you to manage. Let me know if you get blocked. If this product has no developer workflow you can act on, say so plainly and stop. Stay light: use the hosted product through its SDK or API. Do not start local service stacks or wait for long-running commands; if the quickstart requires either, say so plainly and stop. No product credentials were supplied and no purchases were authorized. ## Score: B · 81/100 (provisional) Grades come from completed site checks. Coding sessions and skipped checks do not affect the score. ### Clarity - **Failed** — Homepage answers Markdown requests ```text Homepage returned text/html for a text/markdown request; no Markdown representation offered. ``` - **Pass** — llms.txt provides an actionable documentation index ```text llms.txt links abridged and full docs plus GitHub, Rust API docs and Discord. ``` - **Pass** — llms.txt provides navigation guidance ```text llms.txt organizes content with 'When to use', features, trade-offs and documentation sets. ``` - **Pass** — llms.txt mentions offered API, MCP, and skills ```text llms.txt notes no HTTP API or MCP, and points to Rust API docs and bindings. ``` - **Pass** — A compact guide representation exists ```text llms.txt offers abridged and complete Markdown documentation sets for SlateDB. ``` - **Pass** — A focused guide is directly retrievable ```text quickstart.md returns text/markdown with install and usage steps for five languages. ``` - **Pass** — Equivalent instructions fit a token budget ```text quickstart.md is 942 tokens, well under the 8000-token guide budget. ``` - **Skipped** — Product-docs links survive format changes ```text Homepage Markdown unsupported, so link preservation across formats cannot be measured. ``` - **Pass** — The compact guide is independently actionable ```text Quickstart gives per-language install commands and runnable minimal examples for Rust, Go, Java, Node, Python. ``` - **Pass** — Install and next-step links resolve ```text Fetched quickstart, docs intro, docs.rs crate page and llms.txt all returned 200. ``` ### Onboarding - **Pass** — Docs lead to a relevant quickstart ```text Docs nav links Quick Start; quickstart.md gives install and runnable examples per language. ``` - **Pass** — Installation commands are extractable ```text Quickstart lists cargo add, go get, Gradle/Maven, npm install, pip install commands. ``` - **Pass** — Code examples are available without interaction ```text Quickstart shows full Rust, Go, Java, Node and Python examples inline without interaction. ``` - **Pass** — Prerequisites and auth boundaries are explicit ```text Quickstart states language version prerequisites and object-store URL configuration; no auth needed. ``` ### Pricing - **Skipped** — Pricing is readable without interaction ```text Not applicable: the relevant product is free. SlateDB is Apache 2.0 free and open source; no pricing page was fetched. ``` - **Skipped** — Prices are stated, not gated ```text Not applicable: the relevant product is free. No pricing page fetched; homepage states Apache 2.0 free and open source. ``` - **Skipped** — Pricing units and limits are explicit ```text Not applicable: the relevant product is free. No pricing units or limits evidence; product is free OSS with no paid plans. ``` - **Skipped** — Agents identify pricing and its assumptions ```text Not applicable: the relevant product is free. SlateDB is Apache 2.0 free and open source; no pricing page was fetched. ``` ### Activation - **Pass** — An API reference or OpenAPI spec is reachable ```text Rust API reference on docs.rs and per-language API links (Go, Java, Node, Python) are reachable. ``` - **Skipped** — An MCP server is documented and well-formed ```text No MCP server is documented in the fetched SlateDB pages. ``` - **Skipped** — A CLI install path is documented ```text Quickstart covers library installs; no CLI install path was fetched. ``` - **Pass** — SDK packages resolve on their registries ```text npm @slatedb/uniffi and PyPI slatedb registry lookups both returned HTTP 200. ``` - **Skipped** — Agent skills are published ```text No agent skills are published in the fetched SlateDB documentation. ``` [Full report data](https://www.ax-check.com/slatedb.io/report.json)