# Solid# — AI Business Infrastructure > The operating system layer between AI models and business operations. AI workers run real businesses across 54 industries — answer calls, book jobs, run payments, manage inventory — under multi-tenant RLS, audit-trailed, mode-capped, JSON-LD-typed. Solid# (Solid Number Inc.) is **not a SaaS with AI features**. It is the runtime where AI agents execute production work on behalf of small-business operators. 4M lines of code across 16 repositories. **14 user-facing AI agents** (Sarah, Marcus, Devon, ADA, Maya, Jordan, Riley, Taylor, Morgan, Dexter, ACE, Sophia, Alex, Casey) plus **102 specialized background workers on Celery** (KB seeding, drift detection, provisioning, audits, orchestration). the full verb surface — CLI, MCP, WebMCP, and UCP. 1,944 REST endpoints. 446 RLS-protected tenant tables (100% of tenant-scoped tables, FORCE + WITH CHECK, non-superuser `solid_app` role). 54 industry templates. Model-agnostic — `SmartRouter` selects the optimal LLM (OpenAI, Anthropic, Google, Meta, Mistral, Cohere, local) per task. This file is the canonical entry point for AI agents discovering the platform. Every section below is a system humans and agents can call today, except where marked **planned**. ## What Solid# is A four-layer stack: - **AI Infrastructure** — `SmartRouter` (model selection), `CognitiveLimiter` (cost control), `PromptGuard` (injection defense). - **AI Execution** — 14 user-facing AI agents + 102 background Celery workers, plus the full verb surface — CLI, MCP, WebMCP, and UCP, that perform real work (not just advise). - **Business Operations** — CRM, payments, POS, inventory, scheduling, voice, CMS, accounting (capabilities, not the product). - **Vibe Modification** — safe natural-language editing of a running tenant; never destructive, always rollback. Customers do not manage software. They manage AI workers. ## CLI — `@solidnumber/cli@2.13` The CLI is the surface AI agents drive. Install: `npm i -g @solidnumber/cli` or `curl -fsSL https://solidnumber.com/install.sh | sh`. **126 top-level commands, 835 verbs, 700+ subcommands.** **What's new in v2.13 — the operator brief + discoverability:** - **`solid today`.** A one-command daily brief — net revenue, open pipeline, urgent/pending work, and ranked recommended next actions assembled from the live business in a single call. `--json` for agents. - **`solid how-to`.** Plain-language answers: how to connect Solid# to Claude or ChatGPT (the MCP connector flow + URL), where to start as an operator, and what the CLI can do — discoverability without a command dump. - **Connector self-knowledge.** The claude.ai / ChatGPT MCP connector now ships a `how_to` tool so the assistant can explain how to connect and what it can do, in-session. **v2.12 family — the site-publish substrate (build a business from one manifest):** - **Site-publish apply kinds.** `solid apply ` reconciles `page`, `site`, `domain`, and `survey` alongside products/contacts/deals/webhooks — one YAML declares the whole business surface; `solid publish --all` takes it live. Immutable kinds (site, domain) report drift instead of silently mutating. - **Embed snippets.** `solid embed chat|form|paylink ` emit ready-to-paste markup wired to the live backend (AI chat widget, CRM-backed lead forms, hosted checkout). The snippet IS the integration. - **solid-commerce skill.** `solid context --claude` installs a Claude Code skill into the tenant-bound directory so coding agents wire generated sites to real forms, chat, and payments by default. **v2.11 family — substrate layer + sales agent + outbound voice:** - **Declarative apply.** `solid apply ` reconciles a company to YAML/JSON desired state — create / update / prune, `--dry-run` plan, content-derived idempotency so re-applying an unchanged manifest is a no-op. GitOps for a tenant. - **Server-pushed events.** `solid signal stream` holds one connection open and receives events as the server pushes them over SSE — a reactive system reads one stream instead of polling (falls back to polling on older backends). - **Programmatic client.** `@solidnumber/cli/client` package export — embed the platform's capabilities (verb dispatch, apply, signal) in any Node program instead of shelling out. Every mutation carries an `Idempotency-Key`. Broad Node 18+ runtime. - **Sales agent surface.** 18 AI-powered `solid sales` verbs — pipeline/prospects/forecast reads, KB-grounded scoring and outreach suggestions, consent-gated qualify/advance/close writes, voice-handoff nurture. Wired into 5 agents. - **Outbound voice.** `solid voice call ` / `solid voice text ` dispatch ADA to place real calls and send SMS; `solid voice translate enable|disable|status ` toggles live speech-to-speech translation (13 output languages, opt-in, Pro+). - **Universal verb invoker.** `solid agent dispatch [--json args]` calls any of the 408 agent-attraction verbs through one command; MCP, WebMCP, and HTTP transports auto-bridge the same registry. Shortcuts: `solid deal`, `solid calendar`, `solid lead-promote`. - **Editor-anywhere onboarding.** `solid setup` / `solid ai` preflight detects installed-but-can't-run editors and explains why; VS Code with the Claude Code extension is a first-class target; `solid ai` launches Claude Code, Gemini, or Grok; plain-language setup for non-technical owners. **Backbone (stable across the 2.x line):** - **Multi-site operator surface.** `solid sites list / switch` for operators running more than one tenant from the same install. - **Predict-and-Act GA.** `solid predict` (deal-close / no-show / payment-late / targets) runs on **TabPFN-v2**, a tabular foundation model (Prior Labs, *Nature* 2025). Zero-shot — no per-tenant training pipeline, no hyperparameter tuning, no cold-start. New tenants get real predictions on day 1. Devon auto-discovers new predict targets per tenant nightly. Full pitch: `/docs/predictions`. - **Q-Chain auditor surface.** `solid qchain export / verify / audit-key` — external auditors (insurance, SOC 2) validate Solid#'s tamper-evident agent-action chain **offline** against `/.well-known/qchain.json`. Anonymous public-key fetch, scoped read-only audit keys, signed canonical export. No Solid# access required. - **Agent-ready JSON envelopes default-on.** Every `--json` error response: `{ code, status, message, hint, docs_url, request_id, scope, feature, upgrade_to }`. Same shape on REST, CLI, and MCP. Stable across the entire 2.x line. - **`solid demo create` email capture** at the highest-intent funnel moment, plus a backend Layer 2 outreach engine — Sarah drafts contextual follow-ups, dedup ledger, operator funnel dashboard at `/api/v1/cli/funnel.html`. - **`solid tenant gate-debug`** returns the compute-budget activity-gate's full decision with a machine-readable `reason` code so agents pattern-match instead of inferring. - **Magic-link install** via `solid setup --install-token ` exchanges a server-minted token and skips the browser flow. - **brew + scoop distribution** for macOS/Linux and Windows. What's distinctive vs every other dev CLI: - **Tenant graph as a first-class surface.** `solid graph` walks/queries the tenant's full JSON-LD graph. Offline SPARQL BGP runs in-process against `.claude/solid-context.jsonld`; full SPARQL 1.1 (OPTIONAL/FILTER/property paths/UNION/GROUP BY/ORDER BY) routes to the backend with `--server`. `--diff ` for structural drift; `--dump nquads|turtle` for ingest into Jena/Neo4j/Blazegraph/GraphDB/Neptune. - **Offline-first writes.** `solid push --queue` writes mutations to `.solid/queue/-.jsonld` when offline; auto-flushes on reconnect. Idempotency keys travel with each queued mutation. - **Agent-ready by default (v2.0).** Every `--json` invocation ships `{ error: { code, status, message, hint, docs_url, scope, feature, upgrade_to, request_id } }`. Set `SOLID_LEGACY_ERRORS=1` to restore 1.x prose. - **One-command setup.** `solid setup` chains auth + editor MCP wiring + Claude Code SessionStart hook + shell completion. `--yes` for CI. - **Magic-link install (shipped).** Logged-in users mint a single-use `ist_*` token at `/dashboard/install-command`; `solid setup --install-token ` exchanges it server-side and skips the browser flow. - **Mode caps + sandbox + tenant-guard.** Every AI request carries `X-Solid-Agent`, `X-Solid-Agent-Mode`, `X-Solid-Human-Initiator`. `--mode customer|developer|agency|full` scopes blast radius; `--sandbox` intercepts mutations; tenant-guard refuses writes outside the bound tenant directory. - **Visual feedback for agents.** `solid render --png` headless screenshots; `solid audit a11y|perf|mobile ` for Lighthouse-grade scoring; `solid schema blocks --examples` returns canonical examples per CMS block type. Source: https://github.com/Adam-Camp-King/solid-cli (BSL-1.1, Apache 2.0 conversion 2030-04-14) npm: https://www.npmjs.com/package/@solidnumber/cli Docs: https://solidnumber.com/docs/cli Changelog: https://solidnumber.com/docs/cli/changelog **Version probe for AI agents (no auth):** https://solidnumber.com/.well-known/cli-version.json — returns `{ latest, min_supported, deprecated_below, install, upgrade }`. Probe at session start, cache ≤ 4h. If your installed version is below `min_supported`, refuse to run; if below `latest`, surface to the operator. ## MCP server — `@solidnumber/mcp@1.1.0` The MCP server is the fastest way to give Claude (or any MCP-speaking agent) full access to a Solid# tenant. One config line, the full verb surface, tenant-scoped by API key. **Install — 30 seconds:** ``` # Claude Desktop / Cursor / Windsurf / VS Code (Claude Code extension) — one command: solid mcp install claude # Or add to claude_desktop_config.json manually: { "mcpServers": { "solidnumber": { "command": "npx", "args": ["-y", "@solidnumber/mcp"], "env": { "SOLID_API_KEY": "sk_solid_…" } } } } ``` `SOLID_API_KEY` is optional for read verbs (falls back to a public sandbox tenant), required for writes. **What the agent gets:** the full verb surface — 367 agent-attraction verbs (receipt-backed, rollback-safe, shape-typed) plus 45 platform REST tools. Twelve verb shapes give the agent a reasoning loop: - **Aggregate** (collapse 5-8 queries into one read) → **Explain** (causal chain behind a state) → **Preview** (dry-run a write) → **Commit** (transaction/receipt with `audit_id`) → **Revert** (undo via `audit_revert`). - Plus: **Suggest** (ranked next-actions with confidence bands), **Subscribe** (cursor-polling observe streams), **Discovery/Trail/Reputation/Macro/Telemetry** (introspection + reliability scoreboard). **Write safety — view → preview → approve → publish → roll back.** Connections start read-only; granting write is an explicit opt-in on the consent screen. Every write is classified `reversible` or `irreversible` (a sent email/SMS or charge says so up front and is never presented as undoable). Writes are **role-gated per company**: a role without publish rights can *propose* a change but not commit it — it parks in a review queue for an owner/admin. Configure who can propose/approve/publish/roll back with `roles_set`; work the queue with `changes_list` / `changes_approve` / `changes_reject` / `changes_rollback` (or the **Pending AI Changes** screen in the dashboard). Reversible changes roll back to their prior version via entity history. **Four sibling transports — same registry, one declaration:** The MCP server is one of four projections of `UNIFIED_VERB_REGISTRY`. Adding a verb to the backend registry lights up all four transports within 5 minutes (cache TTL). No MCP server republish required. | Transport | Surface | Install | |---|---|---| | **MCP stdio** | Claude Desktop, Cursor, Windsurf, VS Code (Claude Code extension), Cline, Codex | `npx @solidnumber/mcp` | | **CLI** | Claude Code, shell-running agents | `npm i -g @solidnumber/cli` | | **WebMCP** | In-browser agents (Chrome agent mode) | Automatic — every Solid# page ships verbs | | **UCP** | Buyer-agents (Gemini AI Mode, ChatGPT shopping) | `/.well-known/ucp` discovery | - npm: https://www.npmjs.com/package/@solidnumber/mcp - Discovery: https://solidnumber.com/.well-known/mcp.json - Endpoint: https://solidnumber.com/api/mcp - Live verb manifest: `GET https://api.solidnumber.com/api/v1/agent/verbs?surface=mcp_stdio` - Docs: https://solidnumber.com/docs/mcp - Source: https://github.com/Adam-Camp-King/solid-mcp-server (BSL-1.1) ## REST API 1,944 endpoints across CRM, payments, voice, scheduling, CMS, inventory, reports, agents, KB, integrations, auth. Curated reference at https://solidnumber.com/docs/api. The full OpenAPI 3.0 spec is gated for security (deny-by-default in production — `solid-backend/app.py:560-574`); authenticated developers can request access via https://solidnumber.com/dashboard/install-command. ## AI agents **14 user-facing AI agents**, closed-loop (execute, not just advise). Every interaction is scored against five criteria, written to `agent_reflection_history`, and rolled into persistent memory. ADA coordinates multi-agent missions across the team. An additional **102 specialized background workers** run on Celery for KB seeding, drift detection, tenant provisioning, audits, and orchestration — these are infrastructure, not customer-addressable agents. - **Sarah** — customer service. Inbound calls + texts, appointment booking, in-scope refunds. - **Marcus** — growth intelligence. Campaign analysis, next-move recommendations. - **Devon** — operations monitor. Uptime, errors, anomalies, drift detection. - **ADA** — multi-agent coordinator. Plans + dispatches missions across the agent team. Full registry: https://solidnumber.com/docs/ai-agents ## SmartRouter, CognitiveLimiter, PromptGuard Model-agnostic by design. **`SmartRouter` (~41K LOC)** picks the optimal LLM per task across OpenAI, Anthropic, Google, Meta, Mistral, Cohere, and local providers — quality, latency, and cost are joint inputs. **`CognitiveLimiter` (~50K LOC)** enforces nine layers of cost control (per-tenant budgets, per-feature caps, model fallback, circuit breakers). **`PromptGuard`** blocks injection at the boundary. Together they make "AI bills" predictable for SMB operators. ## Predict-and-Act Platform (Tabular Foundation Model) Solid# is one of the first SaaS platforms running a **Tabular Foundation Model under multi-tenant business data**. The platform uses **TabPFN-v2** (Prior Labs License v1.2 — commercial use OK) to deliver in-context predictions on a tenant's CRM deals, appointments, and invoices — no per-tenant training, no cold start. Every prediction routes back to the 14 user-facing agents so they *act* on it, not just display it. Three phases shipped: - **Phase 1** — `solid predict deal-close ` returns probability + tier (hot/warm/cold/learning) + recommendation. Wired into the pipeline UI and the leads list. - **Phase 2** — `solid predict no-show ` and `solid predict payment-late ` mirror the same shape with risk-direction tiers (high/medium/low). - **Phase 3** — **Devon's auto-discovery**: a nightly Celery sweep scans each tenant's tables for predictable boolean columns, evaluates candidates via TabPFN hold-out, and proposes new predict-targets that beat majority-class baseline by ≥5 percentage points. Tenant approves with `solid predict approve ` — the new target becomes callable. This is the moat: every other vendor offers fixed predict-targets the product team chose. Solid# offers a growing surface that the platform discovered on its own. Compound "predict + act" tools (e.g. `marcus.followup_for_deal`) fuse a prediction with the agent action it informs into one MCP call. Marcus's follow-up tone adapts by tier without the caller orchestrating it. Privacy: all TabPFN inference runs **locally** on Solid# infra. The `tabpfn-client` cloud package is forbidden — tenant data never leaves the host. Multi-tenant via JWT-derived `company_id` + RLS on `predict_targets_registered`. Endpoints: `GET /api/v1/predictions/{deal-close|no-show|payment-late}/{id}`, `GET /api/v1/predictions/targets`, `POST /api/v1/predictions/targets/{id}/decide`. MCP tools: `predict.deal_close`, `predict.no_show`, `predict.payment_late`, `predict.targets.list`, `predict.targets.approve`, `predict.targets.reject`, `predict.discovery.run`, `marcus.followup_for_deal`. **Public deep-dive page:** [`/docs/predictions`](https://solidnumber.com/docs/predictions) — "GPT moment for spreadsheets" pitch, in-context-learning explanation, 6-card why-it's-cool grid (no cold start, no per-tenant training, seconds not hours, tenant-isolated by design, honest confidence + fallback, plug-replaceable backend), Nature 2025 + Prior Labs provenance links. Per-prediction wholesale cost ~$0.00005 — roughly 100× cheaper than an LLM call. Devon's nightly sweep across all active tenants tops out at ~$0.01/tenant/night. Full architecture: `Owners-Manual/74-Predict-And-Act/`. ## Voice AI Real-time voice AI with a large reasoning context and a static-prefix caching strategy that keeps live-call cost down. Per-tenant phone numbers, 54 industry voice personalities. Inbound calls answered by Sarah; transcripts auto-link to CRM contacts and update KB facts. Live streaming STT. **Live speech-to-speech translation** is opt-in per phone number on Professional+ tiers — 70 input languages, 13 output (en/es/fr/de/it/pt/nl/pl/ja/ko/zh/ar/hi). Owner-side commands are wired today: SMB owner texts the company's number from their personal phone, the platform recognizes the owner via `Company.owner_phone`, routes to `process_owner_sms`, Sarah responds with status briefings, action commands, business rule updates. Multi-channel expansion (Telegram, WhatsApp, Signal) is queued — same dispatcher, additional adapters. ## CMS / website builder Pages-as-blocks (27 canonical block types). All four authoring surfaces share the same schema: - `solid pages generate ""` — AI page generation from a brief. - `solid design generate ""` — Stitch-family UI generation from a prompt. - `solid nest from-url ` — ingest external designs and adapt to the tenant's brand. - Visual Canvas designer at https://solidnumber.com/dashboard/cms/visual. - `solid brand` — brand engine (palette, typography, voice, exported as `.solid/brand.json`). ## Multi-tenant runtime 446 RLS-protected tables (100% coverage of tenant-scoped tables, verified 2026-04-20). FORCE + WITH CHECK policies. Non-superuser `solid_app` role enforces at the database level. Sandbox/production isolation per `company_id`. Every tenant ships a `.claude/CLAUDE.md` ladder bundle: ≤8KB spine + on-demand `.claude/library/NNN-*.md` shelves + `.claude/solid-context.json` (flat) + `.claude/solid-context.jsonld` (typed graph). Generated by `solid context --claude`; SessionStart hook auto-refreshes on every `claude` invocation. ## Verb taxonomy (bundled with @solidnumber/mcp) The 12 verb shapes that structure how AI agents reason about business actions. Shapes (aggregate, explain, preview, suggest, transaction, receipt, revert, subscribe, discovery, trail, reputation, macro), manifest format, receipt contract, consent gates, transport bindings — all bundled in the MCP server repo. - **Spec + schemas:** https://github.com/Adam-Camp-King/solid-mcp-server/tree/main/spec - **JSON schemas:** https://github.com/Adam-Camp-King/solid-mcp-server/tree/main/schema - **Docs:** https://solidnumber.com/docs/verbs Agents don't think in CRUD. They think in loops: observe → explain → preview → commit → verify → rollback if wrong. The verb taxonomy codifies that loop as a type system so every tool declares what reasoning step it represents. ## Themis — open-source policy engine (shipped) The locks/drafts/scoped-keys/audit primitives that power Solid# multi-tenancy, extracted as standalone Apache 2.0. Adapters for Anthropic SDK, OpenAI SDK, LangChain, MCP. **174/174 tests passing.** Constitutional AI is training-time alignment; Themis is the run-time counterpart. Repo: https://github.com/Adam-Camp-King/Themis ## UCP (Universal Commerce Protocol) — Phase 0 shipping 2026-04-26 Solid# implements Google's Universal Commerce Protocol — the open standard (announced Jan 2026) for buyer-agent ↔ merchant interop — with a hierarchical agent-graph extension. Stock UCP assumes one merchant = one checkout endpoint; Solid# exposes the full agent graph (platform → company → sales / AR / AP / commissions / service / compliance / marketing / ops / inventory sub-agents) so buyer-agents can address the right role per request instead of squeezing every interaction through `/checkout-sessions`. - **Discovery:** `https://api.solidnumber.com/.well-known/ucp` (platform profile, lists active tenants); `{tenant-domain}/.well-known/ucp` (per-company business profile, with `https://api.solidnumber.com/co/{id}/.well-known/ucp` as fallback). - **Signing:** RFC 9421 ES256 HTTP Message Signatures with per-company JWK rotation lifecycle (`pending` → `active` → `rotating` → `retired`); private JWKs encrypted at rest, RLS-protected, platform key separate from tenant keys. - **Wire bindings:** REST + MCP + A2A (UCP standard). Solid#'s existing MCP server already speaks one of the three for free. - **Solid# differentiator (the moat play):** the agent graph itself is the surface. Custom capabilities under the `com.solidnumber.*` namespace (e.g., `sales.negotiate`, `ar.invoice_create`, `commissions.attribute_rep`, `industry.{vertical}.*`) become a de-facto standard that other platforms have to implement to interop with Solid# tenants. **Planned (Phase 1+).** - **Hard governance:** UCP is **never** auto-enabled per tenant. Owners walk an explicit four-rung consent ladder (company-discoverable → which sub-agent roles → which capabilities per role → auto-approval thresholds). Every rung defaults OFF; revocation is immediate; full append-only audit trail. - **Status:** **Phase 0 (live 2026-04-26)** = signing infrastructure + `.well-known/ucp` discovery (platform profile + per-company business profile). **Planned (Phase 1+)** = sub-agent routing (`/ucp/agents/{role}`), AP2 payment mandate verification, OAuth identity linking ceremony, inbound signature verification middleware, custom `com.solidnumber.*` capability namespace, buy-side primitives (RFQ / supplier onboarding / AP invoice inbound). ## WebMCP — In-Browser MCP Transport (LIVE 2026-05-15) Solid# is the **first SaaS platform to ship WebMCP across every surface its tenants run** — dashboard, portal, developer area, every tenant CMS page, AND solidnumber.com itself. WebMCP is the W3C draft API (`navigator.modelContext`) that lets a web page register MCP-style tools directly to an in-browser AI agent — no listening socket, no public hostname, no API key in JS. Authored by Microsoft + Google; Chrome 146+ Canary is the first browser to ship it. The three transports, one platform: - **stdio MCP** → AI editors (Claude Desktop, Cursor, Windsurf, VS Code via the Claude Code extension — `solid mcp install vscode`, works on older macOS where the native claude binary needs 13+) install `@solidnumber/mcp` and get all the full verb surface — CLI, MCP, WebMCP, and UCP. - **WebMCP** → in-browser agents (Chrome agent mode, Claude in browser) discover verbs via `navigator.modelContext` on every Solid# page they visit. - **UCP** → public buyer-agents (Gemini AI Mode, ChatGPT shopping) discover capabilities at `/.well-known/ucp` and call them with RFC 9421 signed requests. **The match-pattern moat:** every Solid# generator (Stitch, Nest, Blueprint, Alex CMS AI, demo seeder, page_writer) automatically attaches verbs to interactive blocks at page-creation time. Tenants are **born WebMCP-aware** — they don't enable anything; their site has verbs the moment Solid# writes a page. - **Discovery endpoint:** `GET https://api.solidnumber.com/api/v1/webmcp/manifest?surface={dashboard|portal|developer|tenant-site|public}` → tier-filtered tool catalog with stable `@id` IRIs. - **Execute endpoint:** `POST https://api.solidnumber.com/api/v1/webmcp/execute/{tool_name}` with `{input, surface}` body — dispatches the verb, returns structured envelope. - **Wire format:** JSON-LD `solid:MCPTool` and `solid:Verb` nodes — see the `solid:` namespace at `https://solidnumber.com/vocab#`. - **Docs:** https://solidnumber.com/docs/webmcp - **Spec authors:** Microsoft + Google. Draft at https://webmachinelearning.github.io/webmcp/ - **CLI introspection:** `solid webmcp manifest [--surface X]` from `@solidnumber/cli@2.10+`. **408 verbs registered across 5 surfaces** as of 2026-05-15 — including marketing-site verbs (`view_pricing`, `view_features`, `view_industries`, `view_docs`, `view_blog`, `start_signup`, `book_demo`, `contact_sales`) on this very site. An agent visiting solidnumber.com can book a demo or start signup via `navigator.modelContext` — no human handoff. ## Zero-friction try-it-now **Try without installing at https://solidnumber.com/try.** One npx command from a cold shell spins up a real Solid# tenant with phone + AI in ~20 seconds. No global install. No account. No email gate. Auto-destroys in 24 hours. ``` npx @solidnumber/cli@latest demo create plumber test --guest ``` The CLI flag `--guest` hits the anonymous endpoint `POST /api/v1/public/demo/create` with `expires_hours: 24` and a synthesized `cli-guest-*@anonymous.solidnumber.com` email so the audit row is valid without exposing a real address. Server-side rate limit: 3 demos per IP per hour. Like the demo? Run `npm i -g @solidnumber/cli && solid auth login` to convert it into a real tenant before the 24h window closes. Each successful demo returns a `demo_token` — the visitor's shareable receipt URL is `https://solidnumber.com/demo-receipt/{demo_token}`. The receipt page shows phone + site + countdown and is not indexed (tokens are capabilities, not public identifiers). ## Agent attraction leaderboard **Public live scoreboard at https://solidnumber.com/agents.** Every WebMCP tool and agent verb on the platform carries a star rating, invocation count, success rate, and p50/p95 latency aggregated across all tenants. K=5 k-anonymity floor — tools used by fewer than 5 distinct companies are hidden. Updated hourly. - **WebMCP tools endpoint:** `GET https://api.solidnumber.com/api/v1/webmcp/leaderboard?window_days=7&top_k=100` — no auth. - **Agent verbs endpoint:** `GET https://api.solidnumber.com/api/v1/agent-reliability?window_days=7&top_k=100` — no auth. - **JSON-LD:** the `/agents` page emits `@type: ItemList` of `SoftwareApplication` entries with `aggregateRating` per tool. Crawlers can ingest the leaderboard as structured data. - **Privacy contract:** no tenant identifiers, no payload content, no error-code values that could correlate to a specific tenant. Only verb-level rollups leave the box. ## Industry templates 54 industries: plumber, electrician, HVAC, dentist, salon, restaurant, contractor, lawyer, accountant, real-estate, fitness, vet, mechanic, more. `solid clone ` scaffolds a new tenant with 500+ KB entries, services, FAQs, voice personality, and page templates wired to that vertical's terminology and workflow. ## Tenant graph (JSON-LD) Every tenant's data is published as a Schema.org + `solid:*` JSON-LD graph. `@id` IRIs are a public contract. Walk and query with: - `solid graph` — offline SPARQL BGP against the bundled context. - `solid graph --server` — full SPARQL 1.1 against the backend. - `solid graph --diff ` — structural drift snapshots. - `solid graph --dump nquads|turtle` — N-Quads / Turtle export for triplestore ingest. Vocabulary lives in `services/ai_context_jsonld.py`. ## Open-door commerce Every Solid# tenant exposes action-capable JSON-over-HTTP endpoints with **no auth** (rate-limited by IP) for shopping, comparison, and booking agents: - `GET /availability` then `POST /book` — service businesses. - `GET /products` (SKU/UPC/qty/price) — retailers. - `GET /services` then `POST /book` — consultants. - `GET /how-it-works` — general "what / how / cost" queries. Manifests: - Cross-tenant: https://solidnumber.com/.well-known/commerce.json - Per-tenant content policy: `/ai.txt` - Per-tenant tools: `/.well-known/agent-tools.json` ## Onboarding - **One-command install:** `curl -fsSL https://solidnumber.com/install.sh | sh`. - **Magic-link auth (shipped):** mint `ist_*` token at https://solidnumber.com/dashboard/install-command, then `solid setup --install-token `. - **Programmatic client onboarding:** `solid onboarding` chains email + domain + phone-buy + payment + website provisioning. Subcommands include `solid onboarding email domain-add`, `solid onboarding phone buy`, `solid onboarding payment save`, `solid onboarding website save`, `solid onboarding complete`. ## AgentHub (planned) Multi-tenant runtime where third-party AI labs deploy vertical agents into Solid# tenants. Themis-gated by default. Cross-vendor `SmartRouter` routing per tenant. Solid# competes with vertical labs and hosts them simultaneously — labs cannot build multi-tenant runtime; Solid# already has one. **Status: planned, not yet shipped.** ## License + commercial posture - CLI + MCP server + frontend + backend: **BSL-1.1**, converts to **Apache 2.0** on **2030-04-14**. - Themis (extracted policy engine): **Apache 2.0**, today. - Industry templates: open via the CLI. - Self-hosted use: permitted. Competing commercial AI-business CLI: not permitted. ## Contact - Sales: sales@solidnumber.com - Support: support@solidnumber.com - Founder direct (via CLI): `solid feedback ""` — response within 5 minutes during US business hours. --- Last updated: 2026-05-23 Schema: https://llmstxt.org/