# AX Check: trysalty.com Checked 2026-09-19. Docs and pricing are clear, but agents disagree on the price. Free $0, Solo $20/mo, Pro $99/mo are stated openly with limits, yet 1 of 3 agent sessions couldn't pin down a real cost figure. ## Onboarding needs a login ## Coding sessions All three independent sessions completed. DeepSeek V4 Pro correctly read the Free/Solo/Pro tiers and their caps and overage terms. Kimi K3 reported conflicting free vs. revenue-share pricing sourced from an FAQ. Qwen 3.8 Max concluded no pricing existed at all, missing the published tiers entirely. ### DeepSeek V4 Pro [View public run](https://agents.withgauge.com/p/runs/e37dc0fe-63b7-4be3-8843-62a3204ff8bf) · [Read transcript](https://www.ax-check.com/trysalty.com/sessions/deepseek.json) Pricing table (Free/Solo/Pro) is tied to explicit assumptions — API call caps, record caps, rate limits, overage rates, and Free-tier 30-day idle-pause trial limit. #### End-to-end onboarding - **Onboarding needs a login**: Agent researched Salty's docs, pricing, and REST API thoroughly, confirmed the hosted API is live (healthz 200, unauthenticated /people returns 401), and wrote a working demo script. But it never obtained a real sk_live_ API key — Salty requires human signup with email verification (disposable addresses rejected), which the agent cannot self-serve. It stopped, plainly stating the blocker, and asked the product owner to supply a key rather than fabricating success. Event 67: ```text {"status":"ok","db":"ok","latency_ms":5} HTTP 200 ``` Event 92: ```text the quickstart requires a **`sk_live_...` API key obtained from human signup + email verification** at `https://trysalty.com/signup` (real inbox required; disposable addresses are rejected). I can't self-serve an account or click an email-verification link, so I could not execute the live write path. ``` Event 90: ```text Missing SALTY_API_KEY. How to get one: 1. Sign up at https://trysalty.com/signup (a real inbox is required — disposable mailboxes are rejected). ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **Signup requires human email verification, blocking self-serve API key**: Salty's quickstart mandates creating an account at trysalty.com/signup and verifying a real email inbox before an sk_live_ API key is issued. This is normal product authentication behavior, not a defect, but it is an unresolved blocker for an autonomous agent with no email access — the demo script correctly detected the missing key and exited rather than faking success. Event 92: ```text I confirmed the hosted API is live (`/healthz` → 200; `/people` without auth → the expected `401 missing_auth`), but the quickstart requires a **`sk_live_...` API key obtained from human signup + email verification** at `https://trysalty.com/signup` (real inbox required; disposable addresses are rejected). I can't self-serve an account or click an email-verification link, so I could not execute the live write path. ``` #### Suggested Changes - **Publish the @salty/sdk package to npm**: Docs (introduction.md, quickstart.md, api-reference/introduction.md) repeatedly show `import { Salty } from '@salty/sdk'` as the recommended SDK path, but querying the npm registry for @salty/sdk returns Not found. Publish the package under that name (or update the docs to point at the actual published package) and confirm by running `npm view @salty/sdk` and getting real version metadata. Event 46: ```text === npm @salty/sdk === {"error":"Not found"} ``` Event 47: ```text import { Salty } from '@salty/sdk'; const salty = new Salty({ apiKey: process.env.SALTY_API_KEY! }); ``` - **Add a scripted/API-only signup path without email verification for agent onboarding**: The quickstart already documents a scripted bootstrap flow (POST /workspaces/bootstrap with a Supabase JWT) but obtaining that JWT still starts with human signup + email verification at /signup. If the goal is agent-first onboarding, document or provide a fully non-interactive path (e.g., a signed CLI/API token flow) so a coding agent can provision a workspace without a human clicking a verification email, and confirm by having a script obtain a key end-to-end with zero manual steps. Event 47: ```text (For purely scripted setups, hit `POST $SALTY_API/workspaces/bootstrap` with a Supabase JWT to provision a workspace + first key idempotently.) ``` Event 92: ```text the quickstart requires a **`sk_live_...` API key obtained from human signup + email verification** at `https://trysalty.com/signup` ``` ### Kimi K3 [View public run](https://agents.withgauge.com/p/runs/cb6f56f1-e6eb-4316-bb44-381981cb61bd) · [Read transcript](https://www.ax-check.com/trysalty.com/sessions/kimi.json) Final output states consumer pricing is free (sourced from salty.ai FAQ) and partner pricing is revenue-share with no published rate card, explicitly framing the basis (segment: consumer vs. BD-led partner deal) rather than inventing a number. #### End-to-end onboarding - **End-to-end onboarding not demonstrated**: The agent never obtained or used any credentials because no public developer/API surface exists to onboard against. It checked /developers and /docs (both 404) and found only a partner-BD embedded widget (collect.salty.ai) gated behind sales conversations, not self-serve signup. No authenticated operation was attempted or possible. Event 30: ```text timeout 8 curl -sI https://salty.ai/developers -o /dev/null -w "dev:%{http_code}\n"; timeout 8 curl -sI https://salty.ai/docs -o /dev/null -w "docs:%{http_code}\n" ``` Event 32: ```text dev:404 docs:404 ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No public API, SDK, or developer signup exists for salty.ai**: This is product behavior, not agent error or missing test credentials. The agent checked the plausible developer entry points and both returned 404, and the site's only integration surface is a white-label partner widget behind a business-development process, not a self-serve API. Event 32: ```text dev:404 docs:404 ``` Event 34: ```text The only integration surface is a white-label quote widget (`collect.salty.ai`, served as an iframe behind a "Get a Quote" flow) offered to partners through a contact/BD process — not something I can sign up for or call programmatically. ``` - **Ambiguous product name required disambiguation before any work could start**: "Salty" matches multiple unrelated products (npm crypto library, salty-css, salty.ai insurance). The agent spent early turns resolving which one the user meant via web/npm/PyPI lookups before determining the hosted product had no dev workflow. This is an inherent naming collision, not something the product owner can fix on the salty.ai side. Event 9: ```text Network is available. Now let me figure out what "Salty" actually is — there are a few things with that name. ``` Event 22: ```text salty.ai returned 200 — let me see what that hosted product is before deciding. ``` #### Suggested Changes - **Publish a developer/API docs page or clearly state none exists**: salty.ai/developers and salty.ai/docs both return 404 with no redirect to partner-integration information. If a developer surface is intended only for vetted partners, add a page (even a simple redirect from /developers) explaining the BD-led partner process so automated or self-serve evaluators are not left guessing after two 404s. Event 32: ```text dev:404 docs:404 ``` ### Qwen 3.8 Max [View public run](https://agents.withgauge.com/p/runs/3ca4b27c-98d1-4ec5-bf45-7a2a9c21436f) · [Read transcript](https://www.ax-check.com/trysalty.com/sessions/qwen.json) Final output states 'there is no pricing' for any real candidate and never quotes a cost figure or assumptions (plan/region/machine size) — rubric requires a stated price, which is absent. #### End-to-end onboarding - **End-to-end onboarding not demonstrated**: No product credentials were ever obtained or used. The agent searched PyPI, npm, and GitHub for a product called 'Salty' and concluded no such hosted product exists (found only unrelated local tools: a PyPI password-manager CLI, an npm encryption library, and SaltStack). Since there was no hosted API/service to sign up for, no self-service onboarding attempt occurred and none was possible in this session. Event 32: ```text there is no hosted "Salty" product with an SDK/API and pricing that I can act on. ``` Event 32: ```text None of these have: - A hosted service endpoint or account signup - An API key / SDK pointed at a paid backend - Published pricing (per-request, per-seat, usage tiers, etc.) ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No hosted 'Salty' product exists to build against**: The agent searched PyPI, npm registry, and GitHub for 'Salty' and found only unrelated projects: a local password-management CLI (PyPI), a public-key encryption library (npm), and SaltStack config management (self-hosted, no pricing tier). None have a hosted API, signup flow, or published pricing, so the requested task (build an example against Salty's hosted SDK/API, explain pricing) could not proceed. This is not a product defect or agent error — it reflects that the named product does not exist as a hosted, priced developer offering, per the agent's own research. Event 24: ```text Salty 0.1.4 Password management tool https://github.com/markcial/salty ``` Event 29: ```text salty Alternative public key encryption https://github.com/carlos8f/salty ``` Event 32: ```text Salt / SaltStack (VMware) | Self-hosted config management | No hosted tier, no usage pricing — it's free open source you run yourself ``` #### Suggested Changes None identified in this transcript. ### Task given to each agent Help me build a simple example using Salty. 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 · 84/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 Accept header; no Markdown representation served. ``` - **Pass** — llms.txt provides an actionable documentation index ```text llms.txt links docs, API reference, MCP, CLI, webhooks, concepts and quickstart with descriptions. ``` - **Pass** — llms.txt provides navigation guidance ```text llms.txt groups links under About, Documentation, API Reference, MCP, CLI, Webhooks, Concepts sections. ``` - **Pass** — llms.txt mentions offered API, MCP, and skills ```text llms.txt lists REST API, MCP server, CLI, webhooks and OpenAPI spec sections. ``` - **Pass** — A compact guide representation exists ```text Quickstart served as text/markdown at /docs/quickstart and /docs/quickstart.md. ``` - **Pass** — A focused guide is directly retrievable ```text Quickstart gives concrete steps: get key, create person, add attribute, validate. ``` - **Pass** — Equivalent instructions fit a token budget ```text Quickstart markdown is 1134 tokens, well under the 8000-token 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 concrete steps: get key, create person, add attribute, validate. ``` - **Pass** — Install and next-step links resolve ```text Fetched signup, quickstart, people, and API reference pages all returned 200. ``` ### Onboarding - **Pass** — Docs lead to a relevant quickstart ```text llms.txt links Quickstart; fetched quickstart gives concrete 5-step hero demo. ``` - **Pass** — Installation commands are extractable ```text CLI page shows npm install -g salty-cli and npx salty-cli invocation. ``` - **Pass** — Code examples are available without interaction ```text Quickstart shows curl and TypeScript SDK examples with JSON responses inline. ``` - **Pass** — Prerequisites and auth boundaries are explicit ```text Quickstart requires signup for sk_live_ key; auth header shown explicitly. ``` ### Pricing - **Failed** — Agents identify pricing and its assumptions ```text 3 of 3 sessions were judged on pricing; 1 fell short. DeepSeek V4 Pro: Pricing table (Free/Solo/Pro) is tied to explicit assumptions — API call caps, record caps, rate limits, overage rates, and Free-tier 30-day idle-pause trial limit. Kimi K3: Final output states consumer pricing is free (sourced from salty.ai FAQ) and partner pricing is revenue-share with no published rate card, explicitly framing the basis (segment: consumer vs. BD-led partner deal) rather than inventing a number. Qwen 3.8 Max: Final output states 'there is no pricing' for any real candidate and never quotes a cost figure or assumptions (plan/region/machine size) — rubric requires a stated price, which is absent. This behavioural item does not affect the fast grade. ``` - **Pass** — Pricing is readable without interaction ```text Pricing page renders all three tiers, prices, and limits as static text with no interaction. ``` - **Pass** — Prices are stated, not gated ```text Free $0, Solo $20/month, Pro $99/month stated openly; overage rates also listed. ``` - **Pass** — Pricing units and limits are explicit ```text Each tier lists API calls/month, records, rate limits, and overage pricing per unit. ``` ### Activation - **Pass** — An API reference or OpenAPI spec is reachable ```text llms.txt links an OpenAPI 3.1 spec at api.trysalty.com/openapi.json and a Scalar explorer. ``` - **Pass** — An MCP server is documented and well-formed ```text MCP docs give Streamable HTTP endpoint, OAuth 2.1+PKCE, 15 named tools, client configs. ``` - **Pass** — A CLI install path is documented ```text CLI docs show npm i -g salty-cli, npx salty-cli, and salty login OAuth flow. ``` - **Pass** — SDK packages resolve on their registries ```text npm registry lookup for salty-cli returned HTTP 200; SDK @salty/sdk shown in docs. ``` - **Pass** — Agent skills are published ```text Claude Code plugin page documents a salty skill teaching Salty conventions, installable via marketplace. ``` [Full report data](https://www.ax-check.com/trysalty.com/report.json)