Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
docs(community): expand the IBM, OpenAI, CoinMarketCap and AWS drafts and drop the retired buyback claims
nirholas58ad61df9946
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.mdindex a08cab07c..e870f5d16 100644--- a/ARCHITECTURE.md+++ b/ARCHITECTURE.md@@ -2907,7 +2907,7 @@ CREATE2-deterministic, so `IdentityRegistry` + `ReputationRegistry` share one ad| **Pump.fun** | `pumpfun-monitor` `*/3m` · `pumpfun-graduations-sync` `*/2m` · `pump-agent-stats` `*/10m` · `run-buyback` `hourly` · `run-distribute-payments` `:30 hourly` · `run-coin-cycle` `*/5m` · `run-coin-payouts` `*/5m` · `cosmetic-splits-sweep` `:15 hourly` || **Smart money / radar** | `smart-money-rollup` `*/5m` · `smart-money-graph` `*/10m` · `radar-watchlist` `*/10m` · `recompute-reputation` `*/10m` || **Trading fan-out** | `copy-fanout` `*/2m` · `mirror-fanout` `*/2m` · `signal-fanout` `*/2m` · `strategy-fanout` `*/2m` · `run-dca` `hourly` · `run-subscriptions` `hourly` |-| **$THREE / treasury** | `three-holders-snapshot` `*/5m` · `treasury-autopilot` `:23 hourly` · `run-three-buyback` `daily 06:00` · `settle-royalties` `daily 03:00` |+| **$THREE / treasury** | `three-holders-snapshot` `*/5m` · `treasury-autopilot` `:23 hourly` · `settle-royalties` `daily 03:00` || **Wallet / custody** | `wallet-intents` `*/10m` · `index-delegations` `*/5m` · `process-withdrawals` `hourly` · `custody-attest` `:17 */6h` · `relayer-balance-check` `*/6h` · `dead-man-switch` `daily 05:00` || **On-chain indexing** | `erc8004-crawl` `*/15m` · `solana-attestations-crawl` `*/10m` · `trader-score-attest` `daily 09:45` · `solana-attest-event-cleanup` `*/10m` || **Avatars / Forge** | `avaturn-seed-cron` `*/1m` · `auto-rig-sweep` `*/5m` · `forge-seed-cron` `*/1m` · `forge-smoke` `daily 09:30` · `avatar-thumbnail-render` `*/10m` (GLB→PNG regen) |@@ -3002,7 +3002,7 @@ The codebase references **~260 distinct `process.env.*` keys** across `api/`; `a| **3D, avatars & forge** | `avatars` · `avatar_regen_jobs` · `avatar_thumbnail_regen_jobs` · `avatar_search_warm_cache` · `avatar_vrm_compat` · `animation_clips` · `mocap_clips` · `forge_creations` · `forge_votes` · `forge_board_winners` · `forge_seed_jobs` · `forge_consumption_redemptions` · `forge_high_redemptions` · `cosmetic_sales` · `cosmetic_creator_splits` · `token_metadata` · `launchpad_pages` || **Patronage & agent services** | `agent_patron_perks` · `agent_patron_prefs` · `agent_paid_services` · `agent_autopilot_proposals` || **Widgets, notifications & RAG** | `widgets` · `widget_views` · `widget_chat_threads` · `widget_chat_messages` · `widget_knowledge_docs` · `widget_knowledge_chunks` · `plugins` · `chat_brand_config` · `notification_events` · `notification_preferences` · `user_alert_configs` · `user_alert_fires` |-| **Indexing, attestations & infra** | `erc8004_agents_index` · `erc8004_crawl_cursor` · `solana_attestations` · `solana_attestations_cursor` · `solana_attest_event_claims` · `solana_agents_index` · `three_holder_snapshot` · `three_holder_snapshot_meta` · `three_rewards_distributions` · `three_buyback_runs` · `usage_events` · `audit_log` · `bot_heartbeat` · `indexer_state` · `webhook_deliveries` · `developer_webhooks` · `referral_visits` · `decision_outcomes` · `agent_activations` · `agent_wallet_balance_log` · `app_flags` (runtime feature flags) |+| **Indexing, attestations & infra** | `erc8004_agents_index` · `erc8004_crawl_cursor` · `solana_attestations` · `solana_attestations_cursor` · `solana_attest_event_claims` · `solana_agents_index` · `three_holder_snapshot` · `three_holder_snapshot_meta` · `three_rewards_distributions` · `usage_events` · `audit_log` · `bot_heartbeat` · `indexer_state` · `webhook_deliveries` · `developer_webhooks` · `referral_visits` · `decision_outcomes` · `agent_activations` · `agent_wallet_balance_log` · `app_flags` (runtime feature flags) || **X (social) automation** | `x_posts` · `x_scheduled_posts` · `x_triggers` · `x_pending_reviews` |> Several tables (e.g. `master_wallets`) are bootstrapped at runtime via `CREATE TABLE IF NOT EXISTS` rather than a migration — see [Known Gaps](#known-gaps--in-progress).@@ -3344,7 +3344,7 @@ Tiers: **CRITICAL** = `req()` in `api/_lib/env.js` (cold-start throw) or prod-fa- **MCP / bridge:** `MCP_RESOURCE`, `MCP_REGISTRY_TOKEN`, `MCP_AGENT_TALK_ENDPOINT`, `MCP_POSE_PREVIEW_BASE`, `MCP_SVM_PAYMENT_ADDRESS`, `MCP_VANITY_PRICE_USD`, `MCP_BRIDGE_EVM_PRIVATE_KEY`/`_SVM_PRIVATE_KEY`, `MCP_BRIDGE_ALLOWED_HOSTS`/`_ALLOWED_PAYTO`/`_ALLOW_HTTP`, `MCP_BRIDGE_BAZAAR_URL`/`_DISCOVER_LIMIT`, `MCP_BRIDGE_MAX_DEPOSIT_ATOMIC`/`_MAX_PRICE_PER_CALL_ATOMIC`/`_MAX_TOTAL_ATOMIC`, `X402_BRIDGE_PORT`/`_ALLOWED_ENDPOINT_ORIGINS`/`_MAX_USDC_MICROS`.- **LLM providers:** `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`/`OPENAI_BASE_URL`, `GROQ_API_KEY`, `NVIDIA_API_KEY`, `OPENROUTER_API_KEY`/`OPENROUTER_FALLBACK_KEYS`, `SAMBANOVA_API_KEY`, `MISTRAL_API_KEY`, `ZAI_API_KEY`, `SILICONFLOW_API_KEY`, `CLOUDFLARE_ACCOUNT_ID`/`CLOUDFLARE_AI_API_TOKEN`, `DASHSCOPE_API_KEY`, `MODELSCOPE_API_KEY`, `GEMINI_API_KEY`/`GOOGLE_API_KEY`/`GOOGLE_GENAI_API_KEY`/`GOOGLE_CLOUD_PROJECT`, `WATSONX_API_KEY`/`_PROJECT_ID`/`_SPACE_ID`/`_URL`/`_MODEL_ID`/`_API_VERSION`/`_GUARDIAN_MODEL_ID`/`_VISION_MODEL_ID`/`_ORCHESTRATE_*`, `GUARDIAN_SEND_CAP_USD`/`GUARDIAN_DISABLE`, `LIVEPEER_API_KEY`, `LONGCAT_WORKER_URL`/`_KEY`, `OMNI_URL`/`NIM_URL`, `CHAT_MODEL`/`CHAT_MAX_TOKENS`/`CHAT_URL`, `KNOWLEDGE_RERANK_ENABLED`, `PUBLISH_SAFETY_DISABLED`/`_MODEL`/`_TIMEOUT_MS`, `VOYAGE_API_KEY`, `BRAVE_API_KEY`, `TAVILY_API_KEY`/`EXA_API_KEY`/`SERPER_API_KEY`/`SERPAPI_API_KEY`, `BIRDEYE_API_KEY`/`GMGN_COOKIE`, `NEYNAR_API_KEY`, `TWITTER_BEARER_TOKEN`/`X_API_BEARER`, `AIXBT_API_KEY`/`_API_BASE`.- **Voice / 3D gen:** `ELEVENLABS_API_KEY`, `NVIDIA_ASR_FUNCTION_ID`/`NVIDIA_A2F_FUNCTION_ID`/`NVIDIA_COSMOS_INVOKE_URL`, `LIVEKIT_API_KEY`/`_SECRET`/`_SERVER_URL`, `GCP_PROJECT`/`GCP_REGION`/`GCP_SERVICE_ACCOUNT_JSON`, `GCP_RECONSTRUCTION_URL`/`_KEY`, `GCP_TRIPOSG_URL`/`GCP_HUNYUAN3D_URL`/`GCP_REMESH_URL`/`GCP_TEXTURE_URL`/`GCP_STYLIZE_URL`/`GCP_SEGMENT_URL`/`GCP_REMBG_URL`/`GCP_TEXT2MOTION_URL`, `HF_TOKEN`/`HF_RECONSTRUCT_SPACE(S)`, `REPLICATE_API_TOKEN`/`_RECONSTRUCT_MODEL`/`_RERIG_MODEL`/`_POLL_MS`/`_TIMEOUT_MS`/`_WEBHOOK_URL`/`_WEBHOOK_SIGNING_KEY`, `NIM_TRELLIS_URL`/`_KEY`/`MODEL_TRELLIS_URL`, `TRIPO_MODEL_VERSION`, `VERTEX_IMAGEN_MODEL`, `CHROMIUM_PACK_URL`/`CHROME_PATH`/`PUPPETEER_EXECUTABLE_PATH`, `AVATURN_API_KEY`/`_API_URL`/`_SEED_ENABLED`, `MIXAMO_TOKEN`, `AVATAR_REGEN_PROVIDER`, `AUTO_RIG_DAILY_PER_USER`/`_GLOBAL_HOURLY`/`_PRIVATE`/`_REQUIRE_TIER`, `FORGE_ORIGIN`/`FORGE_PREFER_FREE`/`FORGE_FREE_POLL_MS`/`FORGE_PAID_GLOBAL_HOURLY`.-- **Pump.fun / $THREE / treasury:** `PUMP_X402_LAUNCHER_SECRET_KEY_B64`, `PUMP_CRON_RELAYER_SECRET_KEY_B64`, `PUMP_DEFAULT_AGENT_MINT`/`_NETWORK`, `PUMP_PLATFORM_FEE_BPS`/`_WALLET`, `PUMP_GRADUATIONS_SOURCE`/`GRADUATIONS_LIST_KEY`/`_MAX_LEN`, `PUMPFUN_BOT_TOKEN`/`_URL`/`PUMPFUN_MCP_URL`, `PUMP_COINS_V2_BASE`/`PUMP_FRONTEND_BASE`, `PUMPKIT_WEBHOOK_SECRET`, `THREE_WS_MARK_ENFORCE`/`ALLOW_UNMARKED_MINT`, `THREE_TOKEN_MINT`/`THREE_MINT`/`THREE_TOKEN_DECIMALS`, `THREE_PRIZE_PAYOUT_KEY`, `THREE_BURN_ADDRESS`, `THREE_QUOTE_TTL_S`, `THREE_ALLOWANCE_DELEGATE_SECRET_KEY_B64`, `THREE_BUYBACK_ENABLED`/`_SECRET_KEY_B64`/`_MIN_USD`/`_MAX_USD`/`_COMMIT_BPS`/`_SLIPPAGE_BPS`, `BUYBACK_BPS`, `PLATFORM_FEE_BPS`, `REWARDS_DISTRIBUTOR_SECRET`, `REFLECTION_DAILY_CAP`/`_DEBOUNCE_MS`/`REFLECT_SWEEP_BATCH`, `REFERRAL_COMMISSION_BPS`, `RIDER_VAULT_ADDRESS`/`_HELIUS_WEBHOOK_SECRET`, `CREDITS_DEPOSIT_WALLET_SOLANA`, `PURCHASE_RECEIPT_KEY`, `VANITY_SERVICE_KEY`/`VANITY_BOUNTY_PAYOUT_KEY`/`VANITY_DROP_FUNDING_KEY`, `COIN_TREASURY_SECRET_KEY_B64`, `COSMETIC_SPLIT_TREASURY_SECRET_KEY_B64`, `CLUB_SOLANA_TREASURY_SECRET_KEY_B64`/`CLUB_EVM_TREASURY_PRIVATE_KEY`/`CLUB_BASE_RPC_URL`/`CLUB_SWEEP_DUST_ATOMICS`.+- **Pump.fun / $THREE / treasury:** `PUMP_X402_LAUNCHER_SECRET_KEY_B64`, `PUMP_CRON_RELAYER_SECRET_KEY_B64`, `PUMP_DEFAULT_AGENT_MINT`/`_NETWORK`, `PUMP_PLATFORM_FEE_BPS`/`_WALLET`, `PUMP_GRADUATIONS_SOURCE`/`GRADUATIONS_LIST_KEY`/`_MAX_LEN`, `PUMPFUN_BOT_TOKEN`/`_URL`/`PUMPFUN_MCP_URL`, `PUMP_COINS_V2_BASE`/`PUMP_FRONTEND_BASE`, `PUMPKIT_WEBHOOK_SECRET`, `THREE_WS_MARK_ENFORCE`/`ALLOW_UNMARKED_MINT`, `THREE_TOKEN_MINT`/`THREE_MINT`/`THREE_TOKEN_DECIMALS`, `THREE_PRIZE_PAYOUT_KEY`, `THREE_BURN_ADDRESS`, `THREE_QUOTE_TTL_S`, `THREE_ALLOWANCE_DELEGATE_SECRET_KEY_B64`, `BUYBACK_BPS`, `PLATFORM_FEE_BPS`, `REWARDS_DISTRIBUTOR_SECRET`, `REFLECTION_DAILY_CAP`/`_DEBOUNCE_MS`/`REFLECT_SWEEP_BATCH`, `REFERRAL_COMMISSION_BPS`, `RIDER_VAULT_ADDRESS`/`_HELIUS_WEBHOOK_SECRET`, `CREDITS_DEPOSIT_WALLET_SOLANA`, `PURCHASE_RECEIPT_KEY`, `VANITY_SERVICE_KEY`/`VANITY_BOUNTY_PAYOUT_KEY`/`VANITY_DROP_FUNDING_KEY`, `COIN_TREASURY_SECRET_KEY_B64`, `COSMETIC_SPLIT_TREASURY_SECRET_KEY_B64`, `CLUB_SOLANA_TREASURY_SECRET_KEY_B64`/`CLUB_EVM_TREASURY_PRIVATE_KEY`/`CLUB_BASE_RPC_URL`/`CLUB_SWEEP_DUST_ATOMICS`.- **Comms / observability:** `TELEGRAM_BOT_TOKEN`/`TELEGRAM_CHANGELOG_CHAT_ID`/`_ALERTS_CHAT_ID`/`_ORACLE_CHAT_ID`/`_SNIPER_CHAT_ID`, `RESEND_API_KEY`/`_AUDIENCE_ID`, `EMAIL_FROM`/`_REPLY_TO`, `SENTRY_DSN`/`_ENVIRONMENT`/`_RELEASE`, `AXIOM_TOKEN`/`_DATASET`/`_URL`, `VAPID_PUBLIC_KEY`/`_PRIVATE_KEY`/`_SUBJECT`, `DEV_TO_API_KEY`, `MEDIUM_INTEGRATION_TOKEN`/`_AUTHOR_ID`, `THREEWS_TWITTER_URL`.- **Cron / multiplayer / games / ops:** `CRON_SECRET`, `WEBHOOK_SECRET`/`ALLOW_UNSIGNED_WEBHOOKS`, `IRL_FIX_SECRET`/`IRL_X402_ALLOWED_HOSTS`, `X402_SWEEP_MAX_PRICE_USD`, `NODE_ENV`/`VERCEL_ENV`, `PUBLIC_APP_ORIGIN`, `MULTIPLAYER_SHARED_SECRET`/`_INTERNAL_URL`/`_URL`/`_API_BASE`, `REALM_TRANSFER_SECRET`, `WORLD_URL`/`WORLDS_URL`/`WORLD_API_BASE`, `GAME_SERVER_URL`, `WALK_URL`/`WALK_BASE`/`WALK_EMBED_BASE`, `GAME_TOKEN_MINT`/`_DECIMALS`/`_TREASURY`/`_SECRET`/`_REWARDS`, `PLAY_GATE_MINT`/`_MIN`/`_SYMBOL`, `HOLDER_MIN_USD`, `AGORA_MAINNET_ENABLED`/`_RECONCILE_MS`/`_DEVNET_MAX_SOL_PER_TASK`/`_MAX_THREE_PER_TASK`/`_THREE_MINT`/`_THREE_TOKEN_ACCOUNT`, `ORACLE_*` (MODE/NETWORK/GLOBAL_KILL/MAX_TRADE_SOL/USE_JITO/ALERT_MIN_TIER/intervals), `SNIPER_MODE`/`_NETWORK`/`_HEARTBEAT_MS`, `ORDERS_MODE`/`_NETWORK`/`SETTLE_MS`, `DCA_ALLOWED_TOKEN_OUT`/`_CHAIN_ID`, `CIRCULATION_*`, `SMART_GRAPH`/`_INTERVAL_MS`, `CLASH_*` (EPOCH_MS/MAX_FACTIONS/MAX_POWER_PER_WALLET/PASS_SECRET/WAR_RESULT_SECRET), `AUTOPILOT_COMPUTE_TREASURY`, `AGENT_WALLET_ALLOWED_ORIGINS`/`_MAX_USDC_MICROS`/`_DAILY_USDC_MICROS`, `AGENT_TRADE_NETWORK`/`_PRICE_SOL`/`AGENT_INVOCATION_NETWORK`/`_PROGRAM_ID`, `LABOR_ESCROW_SECRET_BASE58`/`LABOR_SKILL_ROYALTY_BPS`, `SKILL_LICENSE_ENFORCE`/`_MINTER_KEY`/`_PROGRAM_ID`/`SKILL_NFT_NETWORK`, `ATTEST_AGENT_SECRET_KEY`/`SAS_AUTHORITY_SECRET`, `CUSTODY_ANCHOR_NETWORK`/`_SNAPSHOT_NETWORK`, `ALLOWED_ORIGINS`, `VITE_WALLETCONNECT_PROJECT_ID`, `CZ_REGISTRY_CONTRACT`/`CZ_AGENT_ID`/`_NAME`, `SDP_API_BASE`/`_KEY`, `STUDIO_API_BASE`/`_PUBLIC_BASE`, `THREEWS_API_BASE`/`_ORIGIN`/`THREE_WS_API_BASE`/`_BASE`/`_API_KEY`.- **Test/Ops only (not request surface):** `SMOKE_*`, `X402_BUYER_*`/`X402_TEST_*`/`X402_PAYER_*`, `TEST_EMAIL`/`_PASSWORD`, `GH_TOKEN`/`GITHUB_TOKEN`, `CC_*`, `DEV_API_PROXY`/`DEV_API_UPSTREAM`, `CI`/`DEBUG`/`DRY_RUN`/`HEADED`/`STRICT_A11Y`/`SKIP_NETWORK_TESTS`/`CONFIRM_MAINNET*`/`VERIFY_ONCHAIN_CHAINS`, Vercel/Codespaces platform vars.diff --git a/docs/aws-builder-center-agent-commerce-spine.md b/docs/aws-builder-center-agent-commerce-spine.mdindex 9e9b0c254..843d45793 100644--- a/docs/aws-builder-center-agent-commerce-spine.md+++ b/docs/aws-builder-center-agent-commerce-spine.md@@ -2,7 +2,7 @@venue: AWS Builder Centeraccount: three.ws (official organization account, byline "three.ws")suggested_title: "The agent bought a physical object: building an authorization spine for autonomous commerce"-suggested_description: "How we wired AWS Marketplace entitlements, agent spend policies, and HTTP 402 settlement into one authorization path, and what happened when the thing at the end of that path stopped being an API call and became a printed object in a box."+suggested_description: "How we wired AWS Marketplace entitlements, agent spend policies, a self-hosted x402 facilitator, and per-call settlement into one authorization path, and what happened when the thing at the end of that path stopped being an API call and became a printed object in a box."suggested_tags: [agentic-ai, agent-toolkit, aws-marketplace, generative-ai, blockchain]suggested_canonical: https://three.ws/docs/materializestatus: draft, not yet submitted@@ -12,11 +12,25 @@ status: draft, not yet submittedMost agent-commerce writing stops at the payment. A wallet signs, a transaction confirms, the demo ends. That is the easy half.-The hard half is everything that has to be true *before* the signature, and it does not fit in a payments library. Who is this caller? What is it entitled to? Is this within the budget its owner set, and is that check race-free when four of the owner's agents spend at once? Can the seller on the other end actually settle, or will it take the money and fail? And when the thing being bought is not an API response but a physical object that gets manufactured and shipped, what refuses the purchase that should never have happened?+The hard half is everything that has to be true *before* the signature, and it does not fit in a payments library. Who is this caller? What is it entitled to? Is this within the budget its owner set, and is that check race-free when four of the owner's agents spend at once? Can the seller on the other end actually settle, or will it take the money and fail? What proves, afterwards, that the exchange happened? And when the thing being bought is not an API response but a physical object that gets manufactured and shipped, what refuses the purchase that should never have happened?-We shipped all of that at [three.ws](https://three.ws), an open-source platform (Apache-2.0) where AI agents have 3D bodies, wallets, and the ability to buy services from each other. This article is the authorization spine underneath it: the AWS Marketplace entitlement path, the spend policy that sits between an agent and a key, the preflight check that stops money leaving for a seller who cannot settle, and the physical fulfillment lane at the end. Every claim points at readable source in [our repository](https://github.com/nirholas/three.ws).+We shipped all of that at [three.ws](https://three.ws), an open-source platform (Apache-2.0) where AI agents have 3D bodies, wallets, and the ability to buy services from each other. This article is the authorization spine underneath it: the AWS Marketplace entitlement path with the AWS SDK for JavaScript v3, the spend policy that sits between an agent and a credential, the preflight check that stops money leaving for a seller who cannot settle, the receipt layer that makes it auditable, and the physical fulfillment lane at the end. Every claim points at readable source in [our repository](https://github.com/nirholas/three.ws).-**Status note up front, because AWS builders will check:** three.ws is a verified AWS Partner and the Marketplace SaaS integration described below is built, deployed, and conformant with the Concurrent Agreements requirements AWS made mandatory for new SaaS products on 2026-06-01. The product record itself has not yet been created in the AWS Marketplace Management Portal, so there is nothing to subscribe to on the AWS side today. Everything else here is live and callable without an AWS account. The platform's own runtime runs on Google Cloud Run; the AWS account (`155407237916`, `us-east-1`) hosts the Marketplace integration.+**Status note up front, because AWS builders will check.** three.ws is a verified AWS Partner and the Marketplace SaaS integration described below is built, deployed, and conformant with the Concurrent Agreements requirements AWS made mandatory for new SaaS products on 2026-06-01. The product record itself has not yet been created in the AWS Marketplace Management Portal, so there is nothing to subscribe to on the AWS side today, and the `AWS_MP_*` credentials are correspondingly unset in production (the subscription endpoint answers `503 not_configured`). Everything else in this article is live and callable without an AWS account. The AWS account `155407237916` (`us-east-1`) hosts the Marketplace integration: the IAM user for the metering APIs, the EventBridge relay, and the EULA. The platform's own runtime runs on Google Cloud Run. I would rather say that plainly than let a partner article imply a hosting story that is not ours.++**Contents**++1. Two economies, one authorization path+2. The AWS Marketplace half, and the part of it that is now wrong on the internet+3. The agent half: a budget, not a credential+4. Payment sessions: what "budget" looks like as an API+5. Preflight, re-quotes, and the failure paths that are the actual product+6. Receipts: the part that makes it auditable a year later+7. Can this agent act at all? A different health check+8. The end of the chain stopped being an API response+9. What is open, and what you can lift from it+10. What we would build differently+11. Try it without an AWS account---@@ -31,12 +45,19 @@ An **agent buyer** cannot do any of that. It cannot sign up, cannot accept termsThe mistake we avoided, barely, was building two access-control systems. What we built instead is one authorization check with two front doors:```-AWS Marketplace subscription ──▶ license row ──▶ x402 API key ──┐- ├──▶ one authorize() ──▶ the tool runs-agent wallet ──▶ HTTP 402 challenge ──▶ settled payment ────────┘+AWS Marketplace subscription+ │ ResolveCustomer (SDK v3)+ ▼+ license row ──▶ account link ──▶ API key ──┐+ ├──▶ authorize() ──▶ the tool runs+agent wallet ──▶ 402 challenge ──▶ settled ──┘ │+ ▼+ signed receipt```-Both paths terminate in the same function. Downstream code never asks how the caller was authorized, only whether it was. That single decision is why adding the Marketplace front door did not fork the product.+Both paths terminate in the same function. Downstream code never asks how the caller was authorized, only whether it was. That single decision is why adding the Marketplace front door did not fork the product, and it is the recommendation I would make to anyone adding a marketplace listing to an existing usage-priced API: **resolve both identities to one internal principal as early as possible, and let nothing downstream know the difference.**++Worth being explicit about the billing model, because it is unusual: the AWS Marketplace subscription is a **free front door**. There are no AWS pricing dimensions and no AWS-side metering. Subscribing links an AWS account to a three.ws account and issues an x402 access key; usage is then paid per call in USDC over HTTP 402, exactly as a non-AWS caller pays. Nothing to reconcile on the AWS invoice. We still implemented `MeterUsage`, `BatchMeterUsage`, and `GetEntitlements` against the SDK v3 clients, because a usage-priced dimension is a listing change rather than a re-architecture, and the code path for it should exist before the day you need it.---@@ -50,60 +71,105 @@ For a **new** SaaS integration, `ResolveCustomer` does not populate `CustomerIdeThis matters more than a field rename, because under **Concurrent Agreements** one AWS account can hold several simultaneous agreements for the same product. The buyer's AWS account id therefore does not identify a subscription, and using it as a key produces a bug that only appears for your largest customers, which is the worst possible distribution of a bug.-Our customer row carries all of it: `license_arn` (unique), `agreement_id`, `customer_aws_account_id`, and a nullable legacy `customer_identifier` kept only for lookups of older rows.+Our customer row carries all of it: `license_arn` (unique), `agreement_id`, `customer_aws_account_id`, and a nullable legacy `customer_identifier` kept only for lookups of older rows. Migrating an existing integration means adding columns and a backfill, not rewriting the flow, but you have to key the *new* rows correctly from day one.### The handle in the redirect URL is not the license-After the buyer clicks **Set up your account**, AWS POSTs a short-lived registration token to our registration URL, we resolve it, and we redirect the browser to a welcome page. That URL carries a handle, and the handle is the row's own id, never the license ARN. A grant identifier does not belong in a string that lands in browser history, referrer headers, and access logs.+After the buyer clicks **Set up your account**, AWS POSTs a short-lived registration token to our registration URL. We exchange it, then redirect the browser to a welcome page carrying a handle, and that handle is **the row's own id**, never the license ARN. A grant identifier does not belong in a string that lands in browser history, referrer headers, proxy logs, and analytics.### Lifecycle events moved to EventBridge, and the old path still has to verify-Agreement and license lifecycle notifications now arrive as EventBridge events. Our webhook still accepts the legacy SNS notifications too, and still verifies their signatures properly, because "we stopped checking the signature on the deprecated path" is how a deprecated path becomes an incident.+Agreement and license lifecycle notifications now arrive as EventBridge events. Our webhook still accepts the legacy SNS notifications too, and still verifies their signatures properly, because "we stopped checking the signature on the deprecated path" is how a deprecated path becomes an incident. If you support both, write one handler with two adapters rather than two handlers, so the authorization consequences of an event cannot diverge between them.-### Linking refuses more than it accepts+### The endpoints, and what refuses what++| Endpoint | Purpose |+|---|---|+| `POST /api/aws-marketplace/register` | Registration URL. Receives the token, resolves the license, starts onboarding. Called by AWS. |+| `POST /api/aws-marketplace/subscription` | Lifecycle webhook. EventBridge agreement and license events, plus legacy signature-verified SNS. Called by AWS. |+| `POST /api/aws-marketplace/link` | Attaches a resolved subscription to the signed-in account. Requires a session. |+| `POST /api/aws-marketplace/issue-key` | Mints or returns the x402 API key. Plaintext is returned once, on first issue. |-`link` and `issue-key` both require an active session and both refuse a subscription that belongs to somebody else, so a given AWS subscription can only ever be attached to one three.ws account:+`link` and `issue-key` both require an active session and both refuse a subscription that belongs to somebody else, so a given AWS subscription can only ever be attached to one account:| Status | Meaning ||---|---|| `401 unauthenticated` | No valid session. Sign in and retry. |-| `403 customer_linked_to_other_account` | This subscription is already attached to a different account. |+| `403 customer_linked_to_other_account` | Already attached to a different account. || `404 customer_not_found` | Unknown subscription record. Re-open the setup link from Marketplace. || `409 subscription_inactive` | Cancelled or expired. Re-subscribe first. |-Code: [`api/aws-marketplace/`](https://github.com/nirholas/three.ws/tree/main/api/aws-marketplace), [`api/_lib/aws-marketplace.js`](https://github.com/nirholas/three.ws/blob/main/api/_lib/aws-marketplace.js), and the bridge into the x402 authorization path in [`api/_lib/aws-marketplace-bridge.js`](https://github.com/nirholas/three.ws/blob/main/api/_lib/aws-marketplace-bridge.js).+Note that "the plaintext key is returned once" is a deliberate constraint and it is worth holding even under support pressure. A key you can re-read is a key your support process can leak.++Code: [`api/aws-marketplace/`](https://github.com/nirholas/three.ws/tree/main/api/aws-marketplace), [`api/_lib/aws-marketplace.js`](https://github.com/nirholas/three.ws/blob/main/api/_lib/aws-marketplace.js), the store in `api/_lib/aws-marketplace-store.js`, and the bridge into the shared authorization path in [`api/_lib/aws-marketplace-bridge.js`](https://github.com/nirholas/three.ws/blob/main/api/_lib/aws-marketplace-bridge.js). The SDK v3 clients in use are `@aws-sdk/client-marketplace-metering`, `@aws-sdk/client-marketplace-entitlement-service`, `@aws-sdk/client-s3`, and `@aws-sdk/s3-request-presigner`.----## 3. The agent half: a budget, not a key+## 3. The agent half: a budget, not a credentialThe instinct when you give an agent buying power is to hand it a credential. That is the wrong primitive. A credential is unbounded until revoked, and revocation is a human action that happens after the money is gone.What an agent should get is a **policy**: a budget, a set of allowed counterparties, a per-call ceiling, and an expiry. The agent proves it is acting under that policy on every spend, and the ceiling is enforced where it cannot be raced.-Two implementation notes that cost us real debugging time:+Three implementation notes that cost us real debugging time.-**Reserve, then settle, then complete.** Our agent-to-agent hire ledger writes the row as `pending` and reserves the spend against the owner's policy in the same statement that checks it. The payment then runs over the real rails. Because the protocol verifies before it settles, a failure means no funds moved: we release the reservation and flip the row to `failed`. Only after settlement do we mark `completed` and attach the settlement signature, payer address, and result summary. Our public volume roll-up counts `completed` rows and nothing else, so "volume" means "money actually moved, signature on file", not "requests attempted".+**Reserve, then settle, then complete.** Our agent-to-agent hire ledger writes the row as `pending` and reserves the spend against the owner's policy in the same statement that checks it. The payment then runs over the real rails. Because the protocol verifies before it settles, a failure means no funds moved: we release the reservation and flip the row to `failed`. Only after settlement do we mark `completed` and attach the settlement signature, payer address, and result summary.**Put the guard in the same statement as the state change.** A read-then-write budget check across two statements is a race that concurrent agents will find within hours. Ours are single statements with the condition inline. This sounds obvious written down; it was not obvious while writing the happy path.-The generalisation we now design against: **an autonomous spend needs the same three properties as a database transaction.** Atomic (the check and the reservation are one operation), consistent (the ledger and the policy cannot disagree), and durable (every attempt is logged, successes and failures alike, because the failures are where the fraud and the bugs live).+**Only settled rows count as anything.** Our public volume roll-up filters on `completed` in every aggregate, so "volume" means "money actually moved, signature on file", and pending or failed attempts contribute exactly zero to totals, counts, averages, leaderboards, or the feed. When the ledger is empty the endpoint returns a real zero shape and the page renders its empty state rather than a placeholder number. If you are building a dashboard over an agent economy, decide what a row means **before** you put a number on a page, because the number is what people will quote back at you.++The generalisation we now design against: **an autonomous spend needs the same three properties as a database transaction.** Atomic (the check and the reservation are one operation), consistent (the ledger and the policy cannot disagree), durable (every attempt is logged, successes and failures alike, because the failures are where the fraud and the bugs live).++---++## 4. Payment sessions: what "budget" looks like as an API++The policy idea only works if it is easy to hand out, so we published it as a session primitive: [`@three-ws/agentcore-payments-mcp`](https://www.npmjs.com/package/@three-ws/agentcore-payments-mcp) creates a **budgeted payment session** and lets an agent pay any priced endpoint from it without ever holding a key.++The shape, in plain terms: an owner creates a session with a total budget, a per-call ceiling, an allowlist of recipients, and an expiry. The agent gets a session handle, not a wallet. Every call debits the session atomically. When the budget is gone, the session refuses, and the refusal is a normal, expected, well-typed outcome rather than an error the agent has to interpret.++Two related packages, because different consumers want different ergonomics:++- [`@three-ws/x402-fetch`](https://www.npmjs.com/package/@three-ws/x402-fetch), a drop-in `fetch` wrapper that pays challenges automatically. If your code already speaks `fetch`, this is a two-line adoption.+- [`@three-ws/agent-guards`](https://www.npmjs.com/package/@three-ws/agent-guards), per-agent spend policies and trade guards as a standalone library, if you want the enforcement without the rest of our stack.+- [`@three-ws/onchain-agent-wallets`](https://www.npmjs.com/package/@three-ws/onchain-agent-wallets), which frames the same idea at the chain level: give an agent a spending allowance rather than a private key.++And the merchant side, since half of any economy is the seller: [`@three-ws/x402-server`](https://www.npmjs.com/package/@three-ws/x402-server) turns any HTTP endpoint into a paid one, issuing the challenge and verifying proof.++---++## 5. Preflight, re-quotes, and the failure paths that are the actual product++HTTP 402 as a protocol is elegant: a caller requests, gets a structured challenge with payment requirements, pays, and retries with proof. That is about a third of the work.++The other two thirds are the failure paths, and they are where an agent economy either becomes real or quietly loses money.++**Preflight.** Before paying anyone, ask whether the seller can actually settle: is the challenge well-formed, is the receiving address real, do the declared chain and asset match what is being asked for, does the settlement path respond. We shipped this as a surface ([three.ws/preflight](https://three.ws/preflight)) and a package ([`@three-ws/x402-preflight`](https://www.npmjs.com/package/@three-ws/x402-preflight)), because we learned it by losing calls to sellers that answered a challenge, accepted the proof, and then failed on their own settlement.++**Re-quote handling, bounded at exactly one retry.** If a paid replay itself answers `402`, the seller refused the proof, usually because it re-quoted between probe and replay. In that case the signed transfer is never broadcast, so no money moved and one retry is safe. Our buyer re-fetches the challenge once, settles against the **fresh** requirements, re-applies both the spend cap and the recipient allowlist to the new quote, and reports the retry distinctly in its logs so it shows up as a pattern rather than as noise. One attempt, then stop. An unbounded retry against a re-quoting seller is a slow drain.++**A daily spend cap across the whole loop**, not per call. Per-call caps feel safe and compose into an unbounded total.++**Log the refusal as carefully as the success.** Every autonomous call we make is recorded either way, with the challenge, the decision, and the outcome. Nobody debugs a success.----## 4. Preflight: do not pay a seller that cannot settle+## 6. Receipts: the part that makes it auditable a year later-HTTP 402 as a protocol is elegant: a caller requests, gets a structured `402` challenge with payment requirements, pays, retries with proof. But it says nothing about whether the seller on the other side is actually capable of completing the exchange.+An entitlement answers "may this caller do this". A receipt answers "did this exchange actually happen, and can a third party check". Enterprise buyers ask the second question eventually, and the answer needs to exist before they ask.-We learned this by losing calls to sellers that answered a challenge, took the proof, and then failed on their own settlement path. So we published a preflight check that answers the question before anything moves: is the challenge well-formed, is the receiving address real, does the seller's declared chain and asset match what it is asking for, does its settlement path respond.+Our receipt layer stores signed Offer and Receipt artifacts and keeps them retrievable: at the last footprint audit (2026-08-25) the vault held **58,907 signed artifacts**. Alongside it we run our own settlement facilitator rather than routing through a third party: **110,416 on-chain settlements and 803,483 verifications** at that same audit, with the implementation in the repo under `api/_lib/x402/`. Discovery is a static, public catalog at `/.well-known/x402.json` listing **4,519 priced endpoints**, which is what lets an agent find a seller at all.-A related discipline we hold ourselves to: our own paid caller re-fetches the challenge and settles against the **fresh** requirements if a paid replay itself answers `402`, since that means the seller refused the proof (a re-quote between probe and replay, typically). The signed transfer is never broadcast in that case, so no money moved and exactly one retry is safe. The retry is bounded at one attempt and re-applies both the spend cap and the recipient allowlist to the new quote.+Two lessons that transfer to any metered API, marketplace-billed or not:-If you build an agent that pays for things, budget engineering time for the *failure* paths of the payment protocol. The success path is a weekend. The failure paths are the product.+**Self-hosting the settlement path was worth it.** Not for ideology: for the failure modes. When settlement is a third-party dependency, your outage postmortem has a gap in the middle of it that you cannot close, and your latency floor is somebody else's routing decision.++**Discovery should be a boring static document.** Ours is a file on our own domain, cacheable, diffable, and readable by anything. Every dynamic discovery API we considered would have been a new availability dependency in the middle of a payment flow.----## 5. Can this agent act at all? A different health check+## 7. Can this agent act at all? A different health checkAn unrelated incident reshaped how we think about readiness. An audit found twelve armed autonomous agents: worker `Ready`, minimum instances up, feed streaming, every strategy row enabled. Ten of them had not attempted an action in weeks.@@ -119,13 +185,16 @@ armed, solvency, feed, rpc ──┘rpc ─────────────────────────────> [exit]```-The engine is framework-agnostic with zero dependencies ([`packages/agent-vitals`](https://github.com/nirholas/three.ws/tree/main/packages/agent-vitals)). If you operate a fleet of agents on AWS, this is the check your dashboard is missing, whatever you build it with. "Healthy and structurally unable to work" is a state that will not show up in your existing metrics.+The engine is framework-agnostic with zero dependencies ([`packages/agent-vitals`](https://github.com/nirholas/three.ws/tree/main/packages/agent-vitals)), and there is an operator CLI and an ops-gated HTTP endpoint on our side. If you operate a fleet of agents on AWS, this is the check your dashboard is missing, whatever you build it with. "Healthy and structurally unable to work" is a state that will not show up in your existing metrics, and it is common the moment agents depend on external credit, external models, and funded wallets.++Two siblings from the same problem:-The sibling idea is [Brownout](https://three.ws/brownout): publish **proven** fallbacks rather than promised ones. A failover path nobody has exercised under load is a hypothesis, not a fallback, and every fleet has a folder full of hypotheses labelled as redundancy.+- [Brownout](https://three.ws/brownout): publish **proven** fallbacks rather than promised ones, and expose where a response's data came from and how fresh it is. A failover path nobody has exercised under load is a hypothesis, and every fleet has a folder of hypotheses labelled as redundancy.+- [`@three-ws/witness`](https://www.npmjs.com/package/@three-ws/witness): record what a user actually did and compile it into a Playwright spec that is red while the bug exists and green once it is fixed. A bug report is an experiment somebody else has to reconstruct, and the reconstruction is the part a machine can do.----## 6. The end of the chain stopped being an API response+## 8. The end of the chain stopped being an API responseHere is the part that made all of the above matter more than it did last year.@@ -134,31 +203,58 @@ Here is the part that made all of the above matter more than it did last year.The pipeline, and why each stage exists once the buyer might be a machine:1. **Free, keyless analysis.** A printability report before any price: closed solid or not, how many separate bodies, where the holes are, thinnest wall, exact volume, and a 0 to 100 score with named deductions in plain language. Free on purpose. An agent that can check printability before paying to generate spends less overall, and a check that costs money is a check nobody runs.-2. **A signed quote token**, valid 24 hours, so the quoted price is the paid price and the quote cannot be tampered with in between.+2. **A signed quote token**, valid 24 hours, so the quoted price is the paid price and nothing between the two can move it.3. **Two checkouts, one pipeline.** A human pays in the browser; an agent pays over 402. Same order record, same statuses, same fulfillment.4. **Safety screening before production.** Weapons, functional key duplicates, and third-party brand marks are refused. A print bureau has a human at that checkpoint; an API whose buyer is an agent does not, so the checkpoint has to be code that is allowed to say no.-5. **Provenance in the box.** Every print ships with a certificate of authenticity attested on-chain, with a QR code, so the object can prove which generation produced it. Creators can cap how many copies of a model will ever exist.-6. **Order tracking** at every step, because "the agent bought something and we cannot tell the owner where it is" is not a shippable state.+5. **Provenance in the box.** A certificate of authenticity, attested publicly, with a QR code, so the object proves which generation produced it. Creators can cap how many copies of a model will ever exist.+6. **Order tracking at every step**, because "the agent bought something and we cannot tell the owner where it is" is not a shippable state.++There is a quieter dependency underneath it that is worth naming, because it is the kind of thing that gets discovered in production: a model that renders beautifully can be physically impossible. We publish a separate free grade for the neighbouring question of whether an asset is usable in a **physics engine** ([simulation readiness](https://three.ws/docs/sim-readiness), CC0 spec), for the same reason. **Generative pipelines produce artifacts whose fitness for a downstream physical process is not visible in the artifact.** If your agent pipeline ends in manufacturing, robotics, or simulation, you need a mechanical claim about fitness, made once, checkable by anyone.-The architectural lesson is the one I would take to any team building agent commerce: **irreversibility should be preceded by a free, honest dry run.** Quote is free, detailed, and refusable. Order is the only call that costs anything, and by the time it is made, every question has been asked and answered by a machine that could still change its mind.+The architectural lesson I would take to any team building agent commerce: **irreversibility should be preceded by a free, honest dry run.** Quote is free, detailed, and refusable. Order is the only call that costs anything, and by the time it is made, every question has been asked and answered by a machine that could still change its mind.----## 7. What we would build differently+## 9. What is open, and what you can lift from it-Four things, stated plainly, because partner articles that only contain wins are not useful to anyone.+Everything in this article is Apache-2.0 and installable. As of a footprint audit on 2026-08-25:-**Model the counterparty, not just the call.** For a long time our spend policies constrained amounts and rates. They did not constrain *who*. Recipient allowlists arrived after we needed them, which is the wrong order.+| | |+|---|---|+| npm packages under `@three-ws` | 91 in this repo (101 across the wider scope at audit time) |+| MCP servers in the official registry | 72, under one namespace |+| GPU and service workers | 32, most as Docker images you can build and run |+| Specs (wire formats other code depends on) | 31, several CC0 |+| Public pages | 795 |-**Log failures with the same care as successes.** Every autonomous call we make is recorded, success and failure alike, with the challenge, the decision, and the outcome. Our early failure logging was thinner than our success logging, and that is exactly backwards: nobody debugs a success.+The pieces most worth lifting if you are building agent commerce on AWS, in the order I would reach for them:-**Write the refusal before the interface.** For every capability that touches money or matter, we now write the server-side refusal first and the interface second. A guard that lives in prompt text or in a hidden button is not a guard.+1. `@three-ws/x402-server` (be a seller) and `@three-ws/x402-fetch` (be a buyer).+2. `@three-ws/x402-preflight` (do not pay a seller that cannot settle).+3. `@three-ws/agent-guards` and `@three-ws/agentcore-payments-mcp` (budgets instead of credentials).+4. `@three-ws/agent-vitals` (know whether your fleet can act).+5. `@three-ws/brownout` (know which of your fallbacks are real).+6. `@three-ws/witness` (turn support reports into failing tests).-**Separate the free surface from the paid surface at the server boundary, not with a flag.** Our free 3D generation server has no payment code in it at all. Not disabled: absent. A reviewer can verify that claim in a minute, and so can we, forever.+None of them require the rest of the platform, and none of them require our hosting.----## 8. Try it without an AWS account+## 10. What we would build differently++Four things, stated plainly, because partner articles that contain only wins are not useful to anyone.++**Model the counterparty, not just the call.** For a long time our spend policies constrained amounts and rates but not *who*. Recipient allowlists arrived after we needed them, which is the wrong order.++**Decide what a ledger row means before you publish a number.** We got this right by accident more than by design, and the version where "volume" quietly includes attempts is a number you cannot walk back once people have quoted it.++**Write the refusal before the interface.** For every capability that touches money or matter, write the server-side refusal first and the interface second. A guard that lives in prompt text or a hidden button is not a guard.++**Separate free and paid at the server boundary, not with a flag.** Our free generation server contains no payment code at all. Not disabled: absent. That claim is verifiable in a minute by a reviewer, a customer, or us.++---++## 11. Try it without an AWS accountEverything free below is keyless. Paste and run.@@ -175,10 +271,16 @@ curl -s -X POST https://three.ws/api/print/quote \curl -s https://three.ws/api/mcp-studio \-H 'content-type: application/json' \-d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'++# the public catalog of priced endpoints an agent can discover+curl -s https://three.ws/.well-known/x402.json | head -c 600++# the exact commit and revision production is running+curl -s https://three.ws/api/version```- **Source:** [github.com/nirholas/three.ws](https://github.com/nirholas/three.ws) (Apache-2.0)- **Docs:** [three.ws/docs](https://three.ws/docs), including [Materialize](https://three.ws/docs/materialize), [agent vitals](https://three.ws/docs/agent-vitals), [simulation readiness](https://three.ws/docs/sim-readiness), and the [AWS Marketplace integration](https://three.ws/docs/aws-marketplace)-- **Previous articles from us here:** the AWS Marketplace SaaS metering walkthrough, and the platform overview for AWS builders+- **Previously from us here:** the AWS Marketplace SaaS metering walkthrough with the SDK for JavaScript v3, and the platform overview for AWS builders-Questions about any of it are welcome. The parts I would most like other builders to argue with are section 3 (policy instead of credential) and section 6 (the free dry run in front of the irreversible call), because both started as opinions and only later turned out to be load-bearing.+Questions are welcome. The parts I would most like other builders to argue with are section 3 (policy instead of credential) and section 8 (the free dry run in front of the irreversible call), because both started as opinions and only later turned out to be load-bearing.diff --git a/docs/coinmarketcap-article-2026-09-agent-economy.md b/docs/coinmarketcap-article-2026-09-agent-economy.mdindex 4efdcbab3..3a5f4f0cc 100644--- a/docs/coinmarketcap-article-2026-09-agent-economy.md+++ b/docs/coinmarketcap-article-2026-09-agent-economy.md@@ -1,167 +1,265 @@----title: "The agent economy grew a body: what a three.ws agent can actually buy in September 2026"-target: CoinMarketCap Community / Editorial-status: draft, not yet posted+venue: CoinMarketCap Community (Articles Management > Add a new article)+account: three.ws (official)+categories: Solana, AI, Announcements+assets: THREE+status: draft, owner approval required before posting (external-channel gate in CLAUDE.md)+format_notes: |+ CMC caps the title and the meta description at 191 characters each. The body editor+ offers H2 and H3 only and has no table support (a markdown table pastes as one+ run-on line), so every list below is plain lines. Cover art: 640x360 or that+ proportion, under 10 MB.accuracy_notes: |- Live figures in this draft were read from https://three.ws/api/three-token/stats on- 2026-09-04 and are labelled with that date. Price, market cap and volume move, so the- draft deliberately points at the live endpoint instead of freezing those numbers.- pump.fun verification is read live on every request and is currently not asserted here.- The OKX.AI marketplace listing is under review and is described as such, never as live.- Agent-to-agent volume is quoted only from our own completed-hire ledger; third-party- x402 aggregator volume figures are not repeated because they are inflated.+ Live figures were read from https://three.ws/api/three-token/stats on 2026-09-04 and+ are labelled with that date. Footprint figures come from the open-source audit dated+ 2026-08-25. Price, market cap and volume move, so the draft points at the live+ endpoint instead of freezing them. pump.fun verification is read live per request and+ is described as a mechanism, never asserted. The OKX.AI marketplace listing is under+ review and is described as such. Agent-to-agent volume is quoted only from our own+ completed-hire ledger; third-party x402 aggregator volume figures are not repeated,+ because at least one of them is inflated by roughly three orders of magnitude.----# The agent economy grew a body: what a three.ws agent can actually buy in September 2026+# CoinMarketCap article: the agent economy grew a body-## The demo phase is over, and the receipts are boring on purpose+Paste-ready for the CoinMarketCap form.-Every cycle produces a category that is 90% narrative and 10% software. "AI agents with wallets" has been that category for about a year. The demos all look the same: an agent reads a balance, an agent signs a swap, a countdown timer, a token.+## Title (129 characters)-The interesting question was never whether an agent can sign a transaction. It obviously can. The interesting question is what happens on the other side of the payment, and whether anything real is at the end of it.+```+The Agent Economy Grew a Body: What a three.ws Agent Can Actually Buy Now, From Enterprise Inference to a Printed Object in a Box+```-Here is what changed at [three.ws](https://three.ws) over the last few weeks. An agent can now pay to have a physical object manufactured and shipped. An agent can pay a stranger for thirty seconds of their attention and get the money back if they never answer. An agent can pay per call for enterprise inference with no cloud account of its own. An agent can be hired by another agent, with the spend reserved against its owner's budget before the money moves and the row marked complete only after the settlement signature exists.+## Meta description (190 characters)-None of that is a demo. All of it is code you can read, on rails that settle in USDC, with Solana as the home chain.+```+An agent that can sign a transaction is not news. An agent that can pay for manufacturing, a stranger's attention, or Granite inference is. The open-source stack behind it, and the receipts.+```-This piece is the tour: the identity layer, the payment layer, what is actually purchasable, the honest numbers, and where the whole thing is listed. $THREE is the platform's coin, at `FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump` on Solana.+## Body----## 1. Identity first, because an unidentified agent cannot be paid safely+Every cycle produces a category that is 90% narrative and 10% software. "AI agents with wallets" has been that category for about a year. The demos all look the same: an agent reads a balance, an agent signs a swap, a countdown timer, a token.++The interesting question was never whether an agent can sign a transaction. It obviously can. The interesting question is what is on the other side of the payment, and whether anything real is at the end of it.++Here is what changed at three.ws over the last few weeks. An agent can pay to have a physical object manufactured and shipped to an address. An agent can pay a stranger for thirty seconds of their attention, and get its money back if the stranger never answers. An agent can pay per call for enterprise-grade inference with no cloud account of its own. An agent can be hired by another agent, with the spend reserved against its owner's budget before any money moves and the row marked complete only after a settlement signature exists.++None of that is a demo. All of it is open-source code you can read, on rails that settle in USDC, with Solana as the home chain. This is the tour: identity, payments, what is actually purchasable, the trading surfaces, the worlds, the phones, the honest numbers, and every place it is listed.++$THREE is the platform's coin, at FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump on Solana.++## Identity first, because an unidentified agent cannot be paid safelyAn off-chain agent has three problems that get worse the more useful it becomes. It can disappear when a host shuts down. It cannot be verified at a distance by a stranger's agent. And it cannot hold value or collect anything it earns.-three.ws anchors every agent to a public ledger. On the EVM side that is ERC-8004, implemented as three Solidity contracts:+three.ws anchors every agent to a public ledger.-- **IdentityRegistry**, an ERC-721 where each agent is a token, so agent ownership is token ownership, transferable and legible to every wallet, marketplace and indexer that already speaks ERC-721. It carries a stable id, an owner, an optional **delegated signer** authorised by EIP-712 to sign as the agent at runtime, and a manifest URI pinned to IPFS.-- **ReputationRegistry**, where signed feedback lives: one score per address per agent, with the review text off-chain at a URI and the chain enforcing who said what about whom and when.-- **ValidationRegistry**, for attestations from allow-listed validators, each carrying a `passed` flag, a proof hash, a proof URI, and a typed kind such as `gltf-validation` or `skill-audit`.+### On EVM: ERC-8004, same address on twelve mainnets-The delegated-signer pattern is the piece that makes autonomy safe rather than reckless: the cold owner key stays in hardware, the runtime holds a hot signer the contract recognises for **actions only**, never for transferring ownership or changing registration.+Three Solidity contracts, deployed by CREATE2 to identical addresses on Ethereum, Optimism, BSC, Gnosis, Polygon, Mantle, Base, Arbitrum, Celo, Avalanche, Linea and Scroll, bytecode-verified, with vanity 0x8004 prefixes that make them recognisable at a glance.-All three deploy via CREATE2 to the same addresses on every supported EVM chain, with vanity `0x8004…` prefixes, so an integrator memorises one address rather than fifteen. Solana is not a checkbox on the side of that: it is the home chain, where the coin lives, where agent wallets settle by default, and where the print certificates are attested.+IdentityRegistry is an ERC-721, so each agent is a token and agent ownership is token ownership: transferable, listable, and legible to every wallet and indexer that already speaks ERC-721. It carries a stable id, an owner, a manifest URI pinned to IPFS, and an optional delegated signer authorised by EIP-712 typed signatures.-As of 2026-09-04 the protocol counts **3,514 registered agents**, read live from `GET /api/three-token/stats`, the same endpoint the site itself reads. That endpoint also returns the live pump.fun verification flag for the coin rather than hardcoding it, with three states (`true`, `false`, and `null` when pump.fun could not be reached), so the badge on the site can never disagree with what pump.fun publishes right now.+That delegated signer is the piece that makes autonomy safe rather than reckless. The cold owner key stays in hardware. The runtime holds a hot signer the contract recognises for actions only, never for transferring ownership or changing registration. An agent can operate continuously in the background without the owner's main key ever being online.----+ReputationRegistry holds signed feedback: one score per address per agent, from minus 100 to plus 100, with the review text off-chain at a URI and the chain enforcing who said what about whom and when. A reviewer cannot be impersonated, cannot double-count, and cannot erase a review after the fact.-## 2. The payment layer, and the parts everyone skips+ValidationRegistry holds attestations from allow-listed validators, each carrying a passed flag, a proof hash, a proof URI, and a typed kind such as gltf-validation, skill-audit, or security-review. This is how an agent's passport can say not only "owned by this address with this reputation" but "validated by these specific reviewers for these specific kinds of correctness".-Payments run over x402: the caller requests, gets a structured HTTP 402 challenge describing what to pay and where, pays, and retries with proof. Elegant, and about a third of the actual work.+### On Solana, which is the home chain and not a checkbox-The other two thirds are the failure paths, and they are where an agent economy either becomes real or quietly loses money:+The identity analog is Metaplex Core: the asset pubkey is the agent id, and SPL Memo anchors reputation and validation attestations. At the last open-source audit on 2026-08-25 there were 3,000 validator attestations written under the platform's validation envelope, and 126,522 custody proofs across 244 epochs.-**Preflight.** Before paying anyone, you can ask whether the seller can actually settle: is the challenge well formed, is the receiving address real, does the declared chain and asset match what is being asked for, does the settlement path respond. Paying a seller that answers a challenge and then fails is a specific, boring way to lose funds, and it happens constantly.+Two Solana programs written in Anchor back the on-chain half: agent invocation and skill licensing. Every coin launched through the platform carries a mint address beginning with 3ws, ground into the keypair itself by a vanity grinder compiled to WebAssembly that runs in the browser.-**Re-quote handling.** If a paid replay itself answers 402, the seller refused the proof, usually because it re-quoted between probe and replay. The signed transfer is not broadcast in that case, so no money moved, and exactly one retry against the **fresh** requirements is safe. That retry re-applies the spend cap and the recipient allowlist to the new quote. One attempt, then stop.+### Wallets that hold an allowance, not a key-**Reserve, settle, complete.** In the agent-to-agent hire path, a row is written `pending` and the spend is reserved against the owner's policy in the same SQL statement that checks it, so four of your agents spending at once cannot race past a budget. Because the protocol verifies before it settles, a failure means no funds moved: the reservation is released and the row flips to `failed`. Only after USDC has settled does it flip to `completed`, with the settlement signature, payer address, and result summary attached.+The instinct when you give an agent buying power is to hand it a credential. That is the wrong primitive: a credential is unbounded until revoked, and revocation is a human action that happens after the money is gone.-That last detail is why the public volume roll-up at [three.ws/agent-economy-volume](https://three.ws/agent-economy-volume) is trustworthy in a way most agent-economy dashboards are not: every aggregate filters on `completed`, so "volume" means "USDC moved on chain, signature on file", and pending or failed hires contribute exactly zero. When the ledger is empty the page renders a real zero and its empty state rather than inventing a number.+What an agent gets instead is a policy. A budget, a set of allowed counterparties, a per-call ceiling, an expiry. It is published as a package for anyone to use: an on-chain spending allowance for an agent rather than a private key, per-agent spend policies and trade guards as a standalone library, and budgeted payment sessions where the agent holds a session handle and never touches a wallet at all.-A related piece of housekeeping worth stating out loud: the payments feed now separates **our own** autonomous spend from third-party demand, because a platform paying its own endpoints and reporting the total as ecosystem volume is the oldest trick in this category and we would rather not be accused of it.+## The payment layer, and the parts everyone skips----+Payments run over x402: the caller requests, gets a structured HTTP 402 challenge describing what to pay and where, pays, retries with proof. Elegant, and about a third of the actual work.++The other two thirds are the failure paths, and they are where an agent economy either becomes real or quietly bleeds money.++### Preflight: do not pay a seller that cannot settle++Before paying anyone, ask whether the seller can actually complete the exchange. Is the challenge well formed. Is the receiving address real. Do the declared chain and asset match what is being asked for. Does the settlement path respond.++We learned this by losing calls to sellers that answered a challenge, accepted the proof, and then failed on their own settlement. It is now a page and a package, and it is free.++### Re-quotes, bounded at exactly one retry++If a paid replay itself answers 402, the seller refused the proof, usually because it re-quoted between probe and replay. In that case the signed transfer was never broadcast, so no money moved and exactly one retry against the fresh requirements is safe. That retry re-applies the spend cap and the recipient allowlist to the new quote, and then stops. An unbounded retry against a re-quoting seller is a slow drain, and it looks like success in your logs.++### Reserve, settle, complete-## 3. What an agent can actually buy+In the agent-to-agent hire path, a row is written pending and the spend is reserved against the owner's policy in the same SQL statement that checks it, so four of your agents spending at once cannot race past a budget. Because the protocol verifies before it settles, a failure means no funds moved: the reservation is released and the row flips to failed. Only after USDC has settled does it flip to completed, with the settlement signature, the payer address and the result summary attached.++That is why the public roll-up at three.ws/agent-economy-volume is trustworthy in a way most agent-economy dashboards are not. Every aggregate filters on completed, so volume means USDC moved on chain with the signature on file. Pending and failed hires contribute exactly zero to volume, counts, averages, leaderboards, and the feed. When the ledger is empty the endpoint returns a real zero and the page renders its empty state rather than inventing a number.++### The rail is ours, end to end++The settlement facilitator is self-hosted, in the repo, not a third-party dependency. At the 2026-08-25 audit it had processed 110,416 on-chain USDC settlements and 803,483 verifications. Nothing routes through anyone else to settle on Solana.++Discovery is a static, public catalog at three.ws/.well-known/x402.json listing 4,519 priced endpoints, every one on Solana mainnet, cacheable and diffable and readable by anything. A dynamic discovery API would have been one more availability dependency in the middle of a payment flow.++The receipt vault holds 58,907 signed Offer and Receipt artifacts, retrievable indefinitely. An entitlement answers whether a caller may do something. A receipt answers whether the exchange actually happened, and lets a third party check. Enterprise buyers ask the second question eventually.++One more piece of housekeeping worth saying out loud: the payments feed now separates the platform's own autonomous spend from third-party demand. A platform paying its own endpoints and reporting the total as ecosystem volume is the oldest trick in this category, and we would rather not be accused of it.++## What an agent can actually buyThis is the part that changed most this quarter.### A physical object-[Materialize](https://three.ws/materialize) turns a generated 3D model into a real one: resin, nylon, colour sandstone, or steel, printed and shipped. Every step is an API, so an agent can order a physical object of a model it generated ninety seconds earlier with nobody in the loop.+Materialize turns a generated 3D model into a real one: resin, nylon, colour sandstone, or steel, printed and shipped. Every step is an API, so an agent can order a physical object of a model it generated ninety seconds earlier with nobody in the loop.++The sequencing is the interesting part.-The sequencing is the interesting part:+Analysis first, free and keyless: a printability report before any price, covering whether the mesh is a closed solid, how many separate bodies it has, where its holes are, its thinnest wall, its exact volume, and a 0 to 100 score with named deductions written in plain language. Free because a check that costs money is a check nobody runs.-1. **Free, keyless analysis** first: a printability report before any price, covering whether the mesh is a closed solid, how many separate bodies it has, where its holes are, its thinnest wall, its exact volume, and a 0 to 100 score with named deductions in plain language. Free because a check that costs money is a check nobody runs.-2. **A signed quote token**, good for 24 hours, so the quoted price is the paid price.-3. **Two checkouts, one pipeline.** A human pays in the browser. An agent pays over 402. Same order, same statuses, same fulfillment.-4. **A safety screen that is allowed to refuse**, before production: no weapons, no functional key duplicates, no third-party brand marks. A print bureau has a human at that checkpoint; an API whose buyer is a machine has to put it in code.-5. **A certificate of authenticity attested on Solana**, with a QR code in the box, so the object proves which generation produced it. Creators can cap how many copies of a model will ever exist.+Then a signed quote token, valid 24 hours, so the quoted price is the paid price and nothing in between can move it.++Then two checkouts on one pipeline: a human pays in the browser, an agent pays over 402, same order and same statuses.++Then a safety screen that is allowed to refuse, before production: no weapons, no functional key duplicates, no third-party brand marks. A print bureau has a human at that checkpoint. An API whose buyer is a machine has to put it in code.++Then a certificate of authenticity attested on Solana, with a QR code in the box, so the object proves which generation produced it. Creators can cap how many copies of a model will ever exist.As far as we know this is the first API where an AI agent can pay for manufacturing.### A stranger's attention, refundable-[Knock](https://three.ws/knock) is a priced door to a person. You publish it, you set what one message from a stranger costs, and the price does the filtering: someone who genuinely needs you buys thirty seconds for a nickel, and a spammer cannot buy a million of them. Delivery is not a badge on a tab: the recipient's 3D companion walks on screen wherever they are on the site and says who is at the door and what they paid.+Knock is a priced door to a person. You publish it, you set what one message from a stranger costs, and the price does the filtering: someone who genuinely needs you buys thirty seconds for a nickel, and a spammer cannot buy a million of them. Delivery is not a badge on a tab you will get to later. The recipient's 3D companion walks on screen wherever they are on the site and says who is at the door and what they paid.++Three properties that matter to a crypto reader.-Three properties that matter to a crypto reader. **The money is the recipient's**: USDC settles directly to the wallet they name, and the platform never takes custody and takes no cut. **A priced door cannot be opened without a payout address**, so the API refuses the save rather than quietly routing a stranger's money to us. And **the refusals run before the payment**: price, daily cap, message length, and block list are all evaluated first, so a knock that was never going to land is never a knock somebody paid for.+The money is the recipient's. USDC settles directly to the wallet they name. The platform never takes custody of it and takes no cut of it.-New this month: knock a stranger and **get your money back if they never answer**, with an escrowed door you can run from your own wallet and inspect against what the chain actually says.+A priced door cannot be opened without a payout address. The API refuses the save rather than quietly routing a stranger's money into a platform wallet.++The refusals run before the payment. Price, daily cap, message length and block list are all evaluated first, so a knock that was never going to land is never a knock somebody paid for.++New this month: knock a stranger and get your money back if they never answer, with an escrowed door you can run from your own wallet and inspect against what the chain actually says.### Enterprise inference, per call, with no cloud account-An autonomous agent cannot sign up for a cloud account, accept terms, and provision a project mid-task. So the metered model inverts the usual one: the operator holds the credentials and funds the inference, and the caller pays a few cents of USDC per call from the wallet it already controls. Enterprise-grade models become a utility an agent can consume the moment it can pay.+An autonomous agent cannot sign up for a cloud account, accept terms, and provision a project mid-task. So the metered model inverts the usual one: the operator holds the credentials and funds the inference, and the caller pays a few cents of USDC per call from a wallet it already controls. Enterprise-grade models become a utility an agent can consume the moment it can pay. The IBM Granite suite built this way is, as far as we know, the first x402-enabled MCP server on IBM Cloud.### Another agent's work-Agents hire agents for paid skills, through the ledger described above. Skill authors can take **royalties** when their skill is used by somebody else's agent, which is the piece that makes publishing a skill an economic act rather than a donation.+Agents hire agents for paid skills through the ledger described above. On top of that sit two primitives that make publishing a skill an economic act rather than a donation: on-chain skill licenses, where each purchased skill is a 1-of-1 SPL NFT, and skill royalties, so the author earns when somebody else's agent uses their work.-### The other rails that shipped alongside+### The rails that shipped alongside-- **Recurring payments**, so an agent can hold a subscription rather than re-negotiating every call.-- **Reputation staking market**, where reputation carries a cost to assert and therefore a meaning.-- **Alpha-drip**, a tiered release ladder where a leader's copy-trade signal reaches higher $THREE tiers first and everyone else after a delay the leader sets. It is off by default, and it delays the reveal, never the record: the intent row is written in full the instant the leader trades, the trade lands in their public track record either way, and the API has no field that could express hiding one. Trying to act early is refused with `409 not_released` by the same statement that changes the status, so it cannot be raced.-- **3D Drops**, limited-run generated collectibles, and **Trader Wrapped**, a season recap for pump.fun traders.+Recurring payments, so an agent can hold a subscription instead of renegotiating every call.----+A reputation staking market, where asserting reputation costs something and therefore means something.-## 4. The 3D half, in one paragraph, because it is the moat+Alpha-drip, a tiered release ladder where a leader's copy-trade signal reaches higher $THREE tiers first and everyone else after a delay the leader sets. It is off by default. It delays the reveal, never the record: the intent row is written in full the instant the leader trades, the trade lands in their public track record either way, and the API has no field that could express hiding one. Acting early is refused with a 409 by the same statement that changes the status, so it cannot be raced, and the delay is shown on the leader's page before anyone subscribes, because a delay discovered from an empty inbox is the version of that feature that destroys trust.-None of the above would be interesting if the agents themselves were text boxes. A three.ws agent is generated from a prompt into a rigged, animated 3D body with 52 ARKit blendshapes for lipsync, embeddable in any website with one HTML tag. The generation lanes run on an owned GPU fleet across open model families, with a failover chain per lane so an unavailable model degrades quality instead of failing the request. Animation is universal: any humanoid skeleton drives the clip library through bone-name mapping across the Mixamo, Avaturn, Unreal, VRM, Daz, MakeHuman and Blender conventions, with no curated allowlist. This quarter the agents also learned to **see their own output** (frames a vision model can actually look at, so generation becomes a loop instead of one shot), to grade a model's **physics readiness** for simulators, and to run in places a browser tab cannot reach: a terminal, a car, a home, a Windows widget, an iPhone, an Android phone, and a Solana Seeker.+## The trading surfaces, briefly----+Copy trading with a public track record. A trader passport that carries it. Ghost-copy, which answers what would have happened if you had copied a given trader. A coin radar that tells you when it is your filter and not the market that is empty. An autonomous sniper fleet with a published oracle model you can run locally. A strategy lab that back-tests against real launches. A signals marketplace where feeds are listed with the terms to get on it. A wallet portfolio view, an airdrop checker, and a season recap.-## 5. The honest numbers+Three of those deserve a sentence more than the rest, because they are unusual.-Every figure below was read on 2026-09-04 from a live endpoint you can call yourself. None of them are frozen into a page anywhere.+The oracle model is published, not just described: the conviction model runs locally, weights and all, so anyone can check what the fleet is actually deciding on.-| Figure | Value | Source |-|---|---|---|-| Registered agents | 3,514 | `GET /api/three-token/stats` |-| $THREE holders | 15,781 | same |-| Price, market cap, 24h volume, liquidity | live | same (they move; read them, do not quote this article) |-| Agent-to-agent volume | live, completed hires only | [three.ws/agent-economy-volume](https://three.ws/agent-economy-volume) |+The sniper's health is measured by whether it can act, not whether it is running. That distinction came from an audit that found twelve armed agents, all healthy by every metric we had, ten of which had not attempted an entry in weeks, because a model chain answered 404, providers were out of credit, and several wallets could not fund a single entry.-Three things we will not do, and they are worth naming because the category is full of them:+And the launch feed is a product surface, not an endorsement: it renders the coins users launched through the platform, from the platform's own launch records.-**We do not repeat inflated third-party volume.** At least one popular x402 aggregator's roll-up overstates our volume by roughly three orders of magnitude. Our own ledger is the number we stand behind, and it is smaller.+## Every coin is a world you can walk into-**We do not count our own spending as demand.** The payments feed separates the two.+The multiplayer half is the piece that makes the rest social. Every pump.fun coin is a live 3D world keyed to its mint address: pick a coin, and you are standing in it with everyone else who did, as a real avatar, talking by voice.-**We do not hardcode a verification badge.** The pump.fun verified flag is read live on every request, with an explicit `null` state for "pump.fun could not be reached", and the badge is one shared component so the public page and the holder dashboard can never disagree.+The market does not sit politely on a panel. Buys ripple green across the plaza, sells ripple red, sustained volume spins the coin totem faster, the rolling percentage change becomes the weather, and a whale trade fires a column of light with a shockwave and a rain of gold. A quiet coin is a calm world. A coin being aped is a thunderstorm.----+There is an in-world trading terminal you can walk up to, an open world anyone can enter, and a holders' world gated by a real holding, so being in the room is itself proof that everyone around you has a stake in the same coin. On top of that sit coin wars between two communities, live events with a real clock, and souvenirs you keep.-## 6. Where this is listed, precisely+## On the phone, and off the browser entirely-Claims in this category drift upward, so here is the exact position on every surface, with the weak ones labelled weak:+The Android app is live on the Solana dApp Store, built as a Trusted Web Activity with every wallet interaction routed to the phone's Seed Vault through Mobile Wallet Adapter, plus a share target, offline handling, home-screen shortcuts, deep links, and an agent glance widget. Seeker owners can prove ownership through the soulbound Genesis Token and get a verified badge on every agent they own. The Google Play listing is in review. The iOS shell is in the repo and has not been submitted.-| Surface | Status |-|---|---|-| **BNB Chain Dappbay** | Live, categorised under AI Agent Launchpad, AI Data, AI Infra |-| **Alibaba Cloud International Marketplace** | Live, with a product listing, a storefront, and an editorial feature on the marketplace blog |-| **AWS Marketplace** | AWS Partner; the SaaS integration is built and deployed, the listing itself is not yet public |-| **Google Cloud Marketplace** | Open to partnership, no listing |-| **Microsoft Azure Marketplace** | On the roadmap |-| **OpenAI plugin directory** | Open to submission; the gating requirement (a public OAuth 2.1 MCP server) is already met |-| **OKX.AI agent marketplace** | Submitted and under review as an ASP agent on X Layer. Not listed yet, and we will not describe it as listed until it is |-| **HackerNoon** | Publishing partner; announcements auto-import from our RSS feed |-| **pump.fun** | The $THREE coin page carries a feature article on the platform |+Beyond phones, an agent's status renders as a glance card on a Windows 11 widget board, in a GitHub README, in a Slack message, or in a terminal, and any avatar runs in a plain terminal at 24 frames a second with no browser and no GPU. There is a home surface, a car surface, and a bridge that lets any assistant control a house without ever being able to open a door it should not.-And the programme affiliations, none of which is an endorsement: **OpenAI** Select Partner in the OpenAI Partner Network; **IBM** Business Partner (the public Granite-backed demo endpoints are independent developer tools, not IBM products and not endorsed by IBM); **AWS** Partner; **Google Cloud for Web3 Startups** member, with production running on Cloud Run; **NVIDIA Inception** member since July 2026, which is a startup programme rather than a partnership; **Quicknode** Startup Program, accepted July 2026, whose RPC endpoints are one rung in the Solana failover chain rather than the whole chain.+## The 3D half, in one paragraph, because it is the moat----+None of the above would be interesting if the agents themselves were text boxes. A three.ws agent is generated from a prompt into a rigged, animated 3D body with 52 ARKit blendshapes for lipsync, embeddable in any website with one HTML tag. Generation runs on an owned GPU fleet across open model families, with a failover chain per lane so an unavailable model degrades quality instead of failing the request. Animation is universal: bone names are canonicalised across the Mixamo, Avaturn, Unreal, VRM, Daz, MakeHuman and Blender conventions and clips are retargeted onto whatever came in, with no curated rig allowlist. This quarter the agents also learned to see their own output, so generation became a loop instead of one shot, and to grade a model's readiness for a physics engine, which matters the moment an asset is destined for a simulator, a game, or a printer.++## The $THREE part, with the mechanics stated plainly++The coin is $THREE on Solana, FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump.++Protocol parameters are read live rather than written into a page: as of 2026-09-04 the stats endpoint reports a 1,000 $THREE burn on agent deploy and a 10 percent revenue-share pool. The same endpoint reports whether the buyback and micro-buy lanes are currently running; on the date of writing they are not, and the page shows that rather than describing a mechanism as if it were firing.++Tiers matter in one specific place: the alpha-drip ladder above, where a leader can choose to release a signal to higher tiers first. That is the only place a holding changes what the software does, and the leader sets it, not the platform.++pump.fun verification is a mechanism here, not a claim. The stats endpoint reads pump.fun's public coin record on every request (cached five minutes) and returns a live flag with three states: true when pump.fun publishes the badge right now, false when it does not, and null when pump.fun could not be reached. The badge is one shared component, so the public page and the holder dashboard can never disagree, and if verification were ever withdrawn the badge would disappear on the next read with no deploy.++## The honest numbers++Live figures, read on 2026-09-04 from an endpoint you can call yourself:++3,514 registered agents, and 15,781 $THREE holders, both from GET /api/three-token/stats.++Price, market cap, 24-hour volume and liquidity are on that same endpoint. They move. Read them; do not quote this article.++Agent-to-agent volume is at three.ws/agent-economy-volume, counting completed hires only.++Footprint figures, from the open-source audit dated 2026-08-25:++110,416 on-chain settlements and 803,483 verifications through a facilitator we host ourselves. 4,519 priced endpoints in the public discovery catalog. 58,907 signed receipt artifacts. 3,000 validator attestations and 126,522 custody proofs on Solana. 91 npm packages in this repo, 72 MCP servers in the official registry, 32 GPU and service workers, 31 specs, around 1,750 test files, and 795 public pages of which 128 landed since 1 August.++Three things we will not do, named because the category is full of them.++We do not repeat inflated third-party volume. At least one popular x402 aggregator's roll-up overstates our volume by roughly three orders of magnitude. Our own ledger is the number we stand behind, and it is smaller.++We do not count our own spending as demand. The payments feed separates the two.++We do not hardcode a verification badge, a partner tier, or a listing status.++## Where this is listed, precisely++Live: the BNB Chain Dappbay directory, categorised under AI Agent Launchpad, AI Data and AI Infra. The Alibaba Cloud International Marketplace, with a product listing, a storefront, and an editorial feature on the marketplace blog. The Solana Mobile dApp Store. The OpenAI GPT Store. The official Model Context Protocol registry, with 72 servers under one namespace. The VS Code Marketplace and Open VSX. The Chrome Web Store, for the walking avatar extension. And a feature article on the $THREE coin page on pump.fun.++Built and waiting: AWS Marketplace, where the SaaS integration is deployed and conformant but the listing itself is not yet public, so there is nothing to subscribe to on the AWS side today. Google Play, in review. The OpenAI plugin directory, open to submission, where the gating requirement of a public OAuth 2.1 MCP server is already met. Google Cloud Marketplace, open to partnership. Microsoft Azure Marketplace, on the roadmap.++Under review, and described as exactly that: the OKX.AI agent marketplace, where the platform is submitted as a service provider agent on X Layer. It is not listed yet, and we will not call it listed until it is.++## The programmes, with no upgrades++OpenAI: Select Partner in the OpenAI Partner Network. A partner designation, not an endorsement.++IBM: Business Partner. The public Granite-backed endpoints are independent developer tools, not IBM products and not endorsed by IBM.++AWS: AWS Partner, with three articles published on the AWS Builder Center and a SaaS metering integration built for Marketplace.++Google Cloud for Web3 Startups: member. Production, the API, and the GPU fleet run on Cloud Run, with Vertex AI in the model chain.++NVIDIA: Inception member since July 2026, with two write-ups on the NVIDIA developer forums. A startup programme, not a partnership and not an endorsement.++Alibaba Cloud: a live marketplace listing and storefront, with Qwen models as lanes in the model router.++Quicknode: accepted into the Startup Program in July 2026. Its RPC endpoints are one rung in the Solana failover chain, not the whole chain.++HackerNoon: publishing partner. Announcements auto-import from the platform's RSS feed and publish with canonical URLs pointing back.-## 7. Why any of this should matter to a crypto reader+## Why any of this should matter to a crypto readerBecause the agent-economy thesis has been stuck at the same demo for a year, and the bottleneck was never the payment protocol.-An agent that can pay is not interesting. An agent that can pay **for something that exists** is a different thing entirely, and getting there required a pile of unglamorous work: a budget that cannot be raced, a preflight that refuses a seller who cannot settle, a safety screen that is allowed to say no to the buyer, a ledger where only settled rows count as volume, and a health model that can tell you an agent is running perfectly and structurally unable to act.+An agent that can pay is not interesting. An agent that can pay for something that exists is a different thing entirely, and getting there required a pile of unglamorous work: a budget that cannot be raced, a preflight that refuses a seller who cannot settle, a safety screen that is allowed to say no to the buyer, a receipt a stranger can verify, a ledger where only settled rows count as volume, and a health model that can tell you an agent is running perfectly and structurally unable to act.That is the whole argument. The narrative layer of this category is saturated. The infrastructure layer is not, and it is where the next real thing gets built.-Everything above is open source under Apache-2.0 at [github.com/nirholas/three.ws](https://github.com/nirholas/three.ws). The free 3D generation lane needs no account, no key, and no wallet: [three.ws/forge](https://three.ws/forge). The coin is $THREE on Solana, `FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump`, and the live protocol figures behind every number in this article are one `curl` away at `https://three.ws/api/three-token/stats`.+Everything above is open source under Apache-2.0 at github.com/nirholas/three.ws. The free 3D generation lane needs no account, no key and no wallet at three.ws/forge. The coin is $THREE on Solana at FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump, and the live figures behind every number in this article are one curl away at https://three.ws/api/three-token/stats.-_Nothing here is financial advice. Read the endpoints, not the adjectives._+Nothing here is financial advice. Read the endpoints, not the adjectives.diff --git a/docs/ibm-community-governed-agents-post.md b/docs/ibm-community-governed-agents-post.mdindex 815601830..3452e6d45 100644--- a/docs/ibm-community-governed-agents-post.md+++ b/docs/ibm-community-governed-agents-post.md@@ -2,7 +2,7 @@title: "When an agent can open your front door, governance stops being paperwork: Granite Guardian, MCP, and the quarter three.ws spent leaving the browser tab"venue: IBM Community, Three.ws User Group (blog post)account: nich (nich8)-description: "A technical write-up for IBM developers: how a governance model built on Granite Guardian became load-bearing once three.ws agents could control a home, ride in a car, and order a physically manufactured object, plus the watsonx.ai surfaces behind it and everything that shipped this quarter."+description: "A long technical write-up for IBM developers: how a governance model built on Granite Guardian became load-bearing once three.ws agents could control a home, ride in a car, and order a physically manufactured object, plus a full tour of the watsonx.ai surfaces, a build-it-yourself walkthrough, and everything that shipped this quarter."status: draft, not yet postedframing_notes: |Every framing rule in docs/ibm.md applies to this draft and must survive any edit:@@ -11,7 +11,7 @@ framing_notes: |models, are not IBM products, are not partnership deliverables, and are not endorsedby IBM. The formal partnership work lives on the IBM platform and is not public.Per the group's posting rules (docs/ops/seo-keyword-plan.md), crypto-cluster content- belongs on three.ws/blog instead. Section 7 is the only part that touches payments,+ belongs on three.ws/blog instead. Section 9 is the only part that touches payments,it is scoped to metering Granite inference for callers with no IBM Cloud account, andit is the section to cut first if the group's rule is applied strictly.---@@ -24,33 +24,46 @@ For most of this group's life, the agents we have been discussing lived in a broThat stopped being true this quarter. A three.ws agent can now be connected to a real house and asked to turn on the kitchen lights. It can ride along in a car. It can take a model it generated ninety seconds ago and have it manufactured in steel and shipped to an address. The blast radius of a wrong decision is now measured in physical objects and unlocked doors.-This post is about what that did to the architecture, and specifically about the piece that turned out to be load-bearing: **a governance model that is allowed to veto an action, running on `ibm/granite-guardian-3-8b` through watsonx.ai.** It is also a catch-up on everything else that shipped, because the group has been quiet since the meetup and a lot has landed.+This post is about what that did to the architecture, and specifically about the piece that turned out to be load-bearing: **a governance model that is allowed to veto an action, running on `ibm/granite-guardian-3-8b` through watsonx.ai.** It is also a full tour of the Granite surfaces underneath, a build-it-yourself walkthrough, and a catch-up on everything else that shipped, because the group has been quiet since the meetup and a lot has landed.Nothing here needs an account to follow along. Every `curl` below runs against a live endpoint.**Before anything else, the affiliation, stated exactly.** three.ws is an IBM Business Partner. The `/api/ibm/*` surfaces described here, and the open-source `@three-ws/ibm-watsonx-mcp` connector, are an independent set of developer tools three.ws built on IBM's publicly available Granite models on watsonx.ai. They are **not** IBM products, **not** official partnership deliverables, and **not** endorsed by IBM. The formal partnership work is being built on the IBM platform and is not yet public. Please do not read any of the below as an IBM release.+**Contents**++1. The shape of the problem+2. Granite Guardian as an action veto+3. The gate we built for houses, and why it refuses locally+4. The full watsonx.ai surface, endpoint by endpoint+5. Build it yourself: a Granite-brained 3D agent in five steps+6. Wiring watsonx.ai into your own client+7. What else shipped this quarter+8. The group, and what is next here+9. One note on metering, for callers with no IBM Cloud account+10. Affiliations and listings, stated plainly+---## 1. The shape of the problemTake three capabilities that all shipped within a few weeks of each other:-- **A home.** An agent connected to [Home Assistant](https://www.home-assistant.io) can read the state of a house and act on it: lights, scenes, climate, and, in principle, locks.+- **A home.** An agent connected to [Home Assistant](https://www.home-assistant.io) can read the state of a house and act on it: lights, scenes, climate, media, and, in principle, locks.- **A car.** A voice-first agent surface for the drive, where reading is not an option and every interaction has to be answerable out loud.-- **Manufacturing.** An API where a generated 3D model becomes a physical printed object, paid for and ordered without a human in the loop.+- **Manufacturing.** An API where a generated 3D model becomes a physical printed object, ordered and paid for without a human in the loop.Each is individually reasonable. Together they change what "a mistake" means. A hallucinated sentence is embarrassing. A hallucinated `lock.unlock` is a break-in. A hallucinated manufacturing order is a box arriving at somebody's house.-The instinct is to solve this with prompt engineering: tell the model to be careful, list the forbidden actions in the system prompt, add a confirmation step in the interface. All three are worth doing and none of them is a control. A system prompt is an argument, and an argument can be won by the other side. An interface confirmation is worthless the moment a second client exists.+The instinct is to solve this with prompt engineering: tell the model to be careful, list the forbidden actions in the system prompt, add a confirmation step in the interface. All three are worth doing and none of them is a control. **A system prompt is an argument, and an argument can be won by the other side.** An interface confirmation is worthless the moment a second client exists, which for us was the moment we published an MCP server.-What is actually needed is boring, and it is the same answer enterprise software arrived at decades ago: **a policy layer between the reasoning and the action, that the reasoning cannot talk its way past.**+What is actually needed is boring, and it is the same answer enterprise software arrived at decades ago: a policy layer between the reasoning and the action, that the reasoning cannot talk its way past, plus a record of every decision that a third party can verify.---## 2. Granite Guardian as an action veto, not a content filter-Granite Guardian is usually introduced as a safety classifier for text. We use it as governance middleware that sits between an agent's reasoning and its actions, classifying a message or a **proposed autonomous action** across named risks (jailbreak, harm, social bias, violence, profanity, unethical behaviour, and more) using `ibm/granite-guardian-3-8b` on watsonx.ai.+Granite Guardian is usually introduced as a safety classifier for text. We use it as governance middleware that sits between an agent's reasoning and its actions, classifying a message or a **proposed autonomous action** across named risks (jailbreak, harm, social bias, violence, profanity, sexual content, unethical behaviour, and more) using `ibm/granite-guardian-3-8b` on watsonx.ai.Each risk is scored from the model's calibrated Yes/No log-probabilities, and the verdicts collapse into a single **allow / review / block** decision.@@ -75,123 +88,246 @@ curl -s https://three.ws/api/guardian/assess \}```-Three properties matter more than the classification itself.+Four properties matter more than the classification itself.**It vetoes.** The same gate runs inline before an agent takes an autonomous value action, and a `block` verdict refuses the action rather than annotating it. A classifier whose output is advisory is a log line, not a control.-**Every verdict is written to a tamper-evident, hash-chained ledger.** Each record commits the hash of the record before it, so the whole chain can be re-verified with SHA-256 by anyone, including a party who does not trust us. When somebody asks six months later why an agent did or did not do something, "we have a chain you can verify" is a different quality of answer from "we have logs".+**It also enforces a budget.** For autonomous sends, the governing call additionally enforces a per-period spend cap, so a request can be vetoed either for risk content **or** for exceeding the cap. Two different kinds of "no" behind one gate is much easier to reason about than two gates.++**Every verdict is written to a tamper-evident, hash-chained ledger.** Each record commits the hash of the record before it, so the whole chain can be re-verified with SHA-256 by anyone, including a party who does not trust us. When somebody asks six months later why an agent did or did not do something, "here is a chain you can verify yourself" is a categorically different answer from "here are our logs".-**It never fabricates a verdict.** If watsonx credentials are absent, the endpoint answers `503 guardian_unconfigured`. There is no mock path anywhere in the integration. An unconfigured safety system that returns `allow` is worse than no safety system, because it produces the paperwork of governance with none of the substance.+**It never fabricates a verdict.** If watsonx credentials are absent, the endpoint answers `503 guardian_unconfigured`. There is no mock path anywhere in the integration. An unconfigured safety system that returns `allow` is worse than no safety system at all, because it produces the paperwork of governance with none of the substance.-Failure modes are all JSON and all named: `400` for a malformed body, `413` over 100 KB, `415` for a wrong content type, `429` for rate limiting, `502 guardian_failed` when watsonx itself fails, and the `503` above. Note what is missing: there is no code path where a failure means "proceed".+The failure modes are all JSON and all named: `400 bad_request` for a malformed body, `405 method_not_allowed`, `413` over 100 KB, `415` for a wrong content type, `429 rate_limited` (per-IP plus an hourly platform-wide ceiling on watsonx inference, charged only by real assessments), `502 guardian_failed` when watsonx itself fails, and the `503` above. Note what is missing: **there is no code path where a failure means "proceed".**++If you want the same thing in your own stack without our platform, the governance layer is published on its own as [`@three-ws/guardian`](https://www.npmjs.com/package/@three-ws/guardian): content safety and governance for AI agents in one import, with Granite Guardian as the primary classifier.---## 3. The gate we built for houses, and why it refuses locally-Home Assistant already owns the device layer: 1,500-plus integrations, every protocol we would otherwise have had to implement, 90k stars, and native Model Context Protocol support. We wrote no device code at all. What was genuinely missing in the world, and what three.ws is placed to build, is the **face**: a real-time 3D presence that stands in a live model of your home, reacts to it, and speaks.+Home Assistant already owns the device layer: 1,500-plus integrations, every protocol we would otherwise have had to implement, around 90k stars, and native Model Context Protocol support since its `mcp_server` integration. We wrote no device code at all. Zigbee, Z-Wave, Matter, Thread, BLE and the long tail are its job. What was genuinely missing in the world, and what three.ws is placed to build, is the **face**: a real-time 3D presence that stands in a live model of your home, reacts to it, and speaks.We also published [`@three-ws/home-mcp`](https://www.npmjs.com/package/@three-ws/home-mcp): five tools that let **any** MCP assistant read the house, list its entities, list the scenes the household already built, run one, and call a service.-The interesting design decision is what happens with the dangerous ones. Every call that would open the house passes through a physical-action gate, and **over stdio that gate refuses outright.** The reasoning: a local stdio MCP server has no user-visible surface, no session, and no way to prove that a human saw a request and approved it. Anything that presents itself as consent in that environment is a fiction. So opening a door is only possible on a surface where a real person can be shown a real prompt, and the local server says plainly that it will not do it and why.+```bash+claude mcp add home \+ -e HOME_ASSISTANT_URL=https://example.ui.nabu.casa \+ -e HOME_ASSISTANT_TOKEN=... \+ -- npx -y @three-ws/home-mcp+```++The interesting design decision is what happens with the dangerous ones. Every call that would open the house passes through a physical-action gate, and **over stdio that gate refuses outright.** Not "prompts". Refuses.++The reasoning: a local stdio MCP server has no user-visible surface, no session, and no way to prove that a human saw a request and approved it. Anything that presents itself as consent in that environment is a fiction. So opening a door is only possible on a surface where a real person can be shown a real prompt, and the local server says plainly that it will not do it and why. The gate has one implementation, shared with [`@three-ws/home-bridge`](https://www.npmjs.com/package/@three-ws/home-bridge), rather than a second copy that can drift out of agreement with the first.++The household model around it follows the same principle, that a refusal must live on the server:-The household model around it follows the same principle, which is that a refusal must live on the server:+- **Five roles**, each stating in plain language, at the moment you choose it, what it can and cannot do. Somebody who lives there can approve unlocking a door. A guest never can, no matter what an agent asks them, and that refusal is enforced server-side, so no client, ours or anyone else's, could offer the button.+- **Scoped access removes data, it does not hide it.** A guest or viewer given only the kitchen receives only the kitchen; the other rooms are stripped from the payload rather than hidden in the interface, so their client never learns those rooms exist.+- **Invitations work once**, expire after a week, and can be withdrawn before anyone uses them.+- **Removing somebody revokes every standing allowance they ever approved**, in the same instant. A door cannot keep opening on the say-so of a person who has left.+- **Attribution.** Every action in the home log names the person who took it.-- Five roles, each stating in plain language, at the moment you choose it, what it can and cannot do. Somebody who lives there can approve unlocking a door. A guest never can, no matter what an agent asks them, and that refusal is enforced server-side, so no client, ours or anyone else's, could offer the button.-- A guest or viewer can be scoped to a single room or three specific devices, and the rooms they were not given are **removed from what they receive**, not hidden on screen. Their client never learns those rooms exist.-- Invitations work once, expire after a week, and can be withdrawn before use.-- Removing somebody revokes every standing allowance they ever approved, in the same instant.-- Every action in the home log is attributed to the person who took it, so "who did what" has an answer.+For houses that are only on a LAN, which is the default Home Assistant install, the house dials us over a single outgoing WebSocket and we never dial the house: no port forwarding, no firewall change, no tunnel daemon, no third-party service, and **no Home Assistant token ever reaches us**, because the integration mints its own credential locally and it never leaves the building. The threat model is published alongside it, which I would recommend to anyone shipping a bridge like this: writing the threat model is what surfaced two of the constraints above.-For houses that are only on a LAN, which is the default Home Assistant install, the house dials us over a single outgoing WebSocket and we never dial the house: no port forwarding, no tunnel daemon, and **no Home Assistant token ever reaches us**, because the integration mints its own credential locally and it never leaves the building. We published the threat model alongside it.+Two more decisions from the same wave, both worth reporting because they are the sort of thing that usually goes unpublished:-One more decision worth reporting because negative results rarely get written up: we evaluated exposing the agent as a **Matter device**, measured what it would cost and what it would buy, and decided against it for now. That write-up is public too.+- **Voice, with an explicit rule that a background "yeah" can never approve a lock.** Confirming a physical action requires an intentional utterance, not an affirmative-sounding noise picked up from a room. Hands-free is the only interface that works when you are carrying groceries, and it is also the interface with the loosest notion of consent, so the bar has to be raised deliberately.+- **We evaluated exposing the agent as a Matter device, measured it, and decided against it for now,** and published that negative result rather than quietly dropping the thread.++There is also a satellite: a Home Assistant voice assistant can wear the agent's face, so the box already sitting in the kitchen gets a body instead of a speaker grille.----## 4. The rest of the watsonx.ai surface, for anyone building on Granite+## 4. The full watsonx.ai surface, endpoint by endpointGranite is a selectable brain for any three.ws agent. The chat proxy resolves watsonx auth lazily inside its failover loop and streams Granite's reply through the standard agent runtime, so a Granite-brained avatar speaks, emotes, and uses skills exactly like any other. It is never the silent default: it is chosen when the request names the watsonx provider, and if watsonx is not configured the provider reports unavailable and the runtime moves on.-The models we run, and what each is for:+**The models we run, and what each is for:**-| Task | Default model |-|---|---|-| Chat and narration | `ibm/granite-3-8b-instruct` |-| Embeddings | `ibm/granite-embedding-278m-multilingual` |-| Time-series forecasting | `ibm/granite-ttm-512-96-r2`, `-1024-96-r2`, `-1536-96-r2` |-| Vision (multimodal) | `ibm/granite-vision-3-2-2b` |-| Governance | `ibm/granite-guardian-3-8b` |+| Task | Default model | Env override |+|---|---|---|+| Chat and narration | `ibm/granite-3-8b-instruct` | `WATSONX_MODEL_ID` |+| Embeddings | `ibm/granite-embedding-278m-multilingual` | `WATSONX_EMBED_MODEL_ID` |+| Time-series forecasting | `ibm/granite-ttm-512-96-r2`, `-1024-96-r2`, `-1536-96-r2` | picked by history length |+| Vision (multimodal) | `ibm/granite-vision-3-2-2b` | `WATSONX_VISION_MODEL_ID` |+| Governance | `ibm/granite-guardian-3-8b` | `WATSONX_GUARDIAN_MODEL_ID` |++The three TinyTimeMixer models encode `<context>-<horizon>` in their names: `ttm-512-96` ingests 512 history points and forecasts up to 96 ahead. Our forecast helper picks the largest model whose context window the available history can actually fill, which removes a whole category of quietly-wrong output where a short series is padded into a large model.++**Embeddings, standalone.** The same Granite vectors are available for your own semantic search or clustering:++```bash+curl -s https://three.ws/api/watsonx/embed \+ -H 'content-type: application/json' \+ -d '{"texts":["a witty trading assistant","a calm meditation guide"]}'+```-The three TimeSeries (TinyTimeMixer) models encode `<context>-<horizon>` in their names: `ttm-512-96` ingests 512 history points and forecasts up to 96 ahead. Our forecast helper picks the largest model whose context window the available history can actually fill, which is a small thing that removes a whole category of quietly-wrong output.+One detail worth copying if you build a similar endpoint: **always read `model` from the response.** Ours leads with Granite on watsonx.ai and falls through to a free-first embedding chain when watsonx cannot serve a full batch, so a `200` does not by itself mean Granite answered. Every vector in a single response comes from one provider, so `dimensions` is uniform within a response and may differ between responses. When nothing at all is configured it answers `503 embed_unconfigured` rather than inventing vectors, and when every configured lane fails at the network level it answers `503 embed_unavailable` with the real upstream cause, which is a retryable status rather than a `502` a caller would read as permanent.-Endpoints, all live:+**Semantic discovery (Agent Galaxy).** Every public agent is embedded with the Granite multilingual embedding model, projected into 3D with PCA, clustered with k-means, and each cluster is named by Granite chat, producing a star-map where semantically similar agents sit near each other. Natural-language search embeds the query and returns nearest agents by cosine similarity, matching on meaning rather than keywords.++The degradation design here is the part I would point a reviewer at. Search has **no provider failover, and none would be correct**, because the stored vectors live in Granite's space and a vector from another lane is a different geometry. So instead of failing, the endpoint degrades the *method*: it ranks the same corpus lexically and answers `200` with `ranking: "lexical"` and `degraded: { reason: "embedder_unavailable", retryable: true }`. A normal search reports `ranking: "semantic"`. **Degrade the method and say so, rather than silently mixing embedding spaces**, is a rule I would generalise to any hybrid search system.++**Forecasting (Granite Oracle).** `GET /api/ibm/oracle` runs a four-stage pipeline: real historical candles from a keyless source, a Granite TimeSeries forecast of the forward series, a two-sentence Granite chat narration of what the forecast says, and a Guardian pass over that narration before it is returned. The response carries history, forecast, stats, narration, the governance verdict, and an `ibm` block naming the forecast model and input window, or the real error reason when a step is unavailable.++**Notarised forecasts (Granite Proof).** Takes a governed forecast, hashes the resulting claim with SHA-256, and writes a compact proof memo publicly, naming the models used, the governance result, and the digest prefix. The behaviour that matters: **if Guardian vetoes the narration, the agent refuses to sign.** There is no proof for a statement that did not pass governance.++**Digital Twin.** Back-test and what-if simulation over the same forecasting stack, for asking what a strategy would have done rather than what a number will be.++**Identity firewall.** Before any new agent identity is created, two Granite checks run. First, semantic impersonation detection: the candidate name and description are embedded and cosine-compared against every existing public agent, with a similarity at or above 93% to another owner's agent treated as impersonation and blocked, and 86 to 93% raising a review warning with the nearest neighbours surfaced. Second, a Guardian content screen classifying the identity text against harm, social bias, and sexual content, with any flagged risk blocking the identity from representing the platform.++```bash+curl -s https://three.ws/api/agents/identity-check \+ -H 'content-type: application/json' \+ -d '{"name":"Granite Oracle","description":"A market oracle that forecasts live prices."}'+```++It is auth-optional: anonymous callers get impersonation detection against all public agents, and authenticated callers also get their own agents included, so the editor can warn "you already have a similar agent". When watsonx is unconfigured it returns `{ configured: false, status: "unavailable" }` and allows the identity, which is a **deliberate fail-open** on a naming check rather than an accidental one. That is the opposite of the Guardian action gate, which fails closed. Choosing the direction per gate, and writing down why, is most of the work.++**Vision.** `ibm/granite-vision-3-2-2b` reads an avatar image into a structured identity, which is how a generated character acquires a described appearance rather than a filename.++**The endpoint map:**| Endpoint | What it does ||---|---|-| `POST /api/guardian/assess` | Guardian governance plus the audit ledger |+| `POST /api/guardian/assess` | Guardian governance plus the hash-chained audit ledger || `GET /api/ibm/oracle` | Granite TimeSeries forecast, narrated and governed |+| `GET/POST /api/ibm/attest` | A governed forecast, hashed and notarised publicly || `GET/POST /api/ibm/twin` | Digital twin: back-test and what-if simulation || `GET/POST /api/ibm/galaxy` | Semantic agent star-map from Granite embeddings |-| `POST /api/agents/identity-check` | Identity firewall: embeddings plus a Guardian impersonation gate |+| `POST /api/agents/identity-check` | Identity firewall: embeddings plus a Guardian screen || `GET/POST /api/ibm/vision` | Granite Vision reads an avatar into an identity || `POST /api/watsonx/embed` | Standalone Granite embedding vectors |-| `GET/POST /api/ibm/attest` | A governed forecast, notarized publicly |-If you would rather wire watsonx.ai into your own client with your own credentials, the open-source connector `@three-ws/ibm-watsonx-mcp` speaks directly to the watsonx.ai REST API. It is community-built, it is not an IBM product, and IBM neither operates nor endorses it.+Live pages: [three.ws/ibm/hello](https://three.ws/ibm/hello) and [three.ws/constellation](https://three.ws/constellation). The browser demo pages that used to sit under `/ibm/*` were retired from navigation; their endpoints remain live and callable, which is why they are documented above rather than linked as pages.----## 5. What else shipped, briefly+## 5. Build it yourself: a Granite-brained 3D agent in five steps++This is the part a member of this group can do in an afternoon, and it stands on its own without the rest of the platform.++**1. Generate a body.** Free, keyless, no account:++```bash+curl -s -X POST https://three.ws/api/3d/studio \+ -H 'content-type: application/json' \+ -d '{"prompt":"a friendly librarian in a knitted cardigan"}'+```++You get either a finished GLB or a job handle with an ETA and a watch URL. Rigging, skinning, and 52 ARKit blendshapes for lipsync come from the avatar lane (`text_to_avatar`) rather than the plain object lane.++**2. Check that the model is actually usable** before you build anything on top of it:++```bash+curl "https://three.ws/api/sim-readiness?src=<your glb url>"+```++Four verdicts, and the useful distinction is between `needs_scale` (geometry is sound, only the units are missing) and `needs_repair` (the surface is open or non-manifold, so mass properties are unreliable).++**3. Give it a brain on watsonx.ai.** Point the agent's provider at watsonx and it thinks on Granite, with the standard runtime handling memory, skills, speech and expression. If watsonx is not configured, the provider reports unavailable rather than pretending.++**4. Put a gate in front of anything it can do.** Run the proposed action through `POST /api/guardian/assess` and treat `block` as a refusal, not a warning. If you are building outside our platform, `@three-ws/guardian` is the same logic as an import.++**5. Embed it.** One tag, any page, no backend on your side:++```html+<script type="module" src="https://three.ws/embed.js"></script>+<agent-3d agent="<id>"></agent-3d>+```++There are wrappers for React, a floating concierge widget, a page narrator that reads the page it lives on, a walk companion, and a guided-tour agent, all as paste-in snippets. If you would rather scaffold the whole thing locally, `npx @three-ws/create-agent` goes from a sentence to a rigged, animated agent in one command.++A note on animation, because it is the step people underestimate: **there is no rig allowlist.** Bone names are canonicalised across Mixamo, Avaturn, Unreal, VRM and VRoid, VRM 1.0, Daz/Genesis, MakeHuman, Blender `.L`/`.R`, and simple `shoulderL` conventions, then clips are retargeted onto whatever came in, legs included. A model that genuinely cannot be skeleton-driven falls back to a default rig rather than standing in a bind-pose T-pose. That logic is published on its own as [`@three-ws/retarget`](https://www.npmjs.com/package/@three-ws/retarget).++---++## 6. Wiring watsonx.ai into your own client++If you would rather not go through our platform at all, the open-source connector speaks directly to the watsonx.ai REST API with **your** credentials, no intermediary backend, no telemetry, and no mock data:++```bash+WATSONX_API_KEY=… WATSONX_PROJECT_ID=… npx @three-ws/ibm-watsonx-mcp+```++Five tools:++| Tool | What it does |+|---|---|+| `watsonx_chat` | Chat completion from role/content messages, with token usage |+| `watsonx_generate` | Raw prompt completion with decoding control |+| `watsonx_embed` | Granite embedding vectors for one or more texts |+| `watsonx_tokenize` | Token count for a text against a model tokenizer |+| `watsonx_list_models` | Foundation models available to your account and region |++It is community-built. It is not an IBM product, and IBM neither operates nor endorses it.++---++## 7. What else shipped this quarterThe group has been quiet; the product has not. The parts most relevant to people here:-**An agent can see its own 3D output.** Every text-to-3D API historically answered with a URL to a binary file, which a human clicks and an agent cannot read. We added a tool that renders a model to frames returned as MCP image content blocks, so a multimodal model **looks** at what it made, judges it, and iterates. That single change is what turns one-shot generation into a loop.+**An agent can see its own 3D output.** Every text-to-3D API historically answered with a URL to a binary file, which a human clicks and an agent cannot read. We added a tool that renders a model to frames returned as MCP image content blocks, so a multimodal model **looks** at what it made, judges it, and iterates. That single change turns one-shot generation into a loop, and it is the highest-leverage thing we shipped this year.++**A physics grade for 3D assets.** A renderer forgives almost everything; a rigid-body solver forgives nothing. `GET /api/sim-readiness` answers whether a GLB is usable as a rigid body right now and, if not, exactly what is wrong. Free, keyless, content-addressed by the file's SHA-256, and the specification is CC0 so anyone can implement it.-**A physics grade for 3D assets.** A renderer forgives almost everything; a rigid-body solver forgives nothing. `GET /api/sim-readiness?src=…` answers whether a GLB is usable as a rigid body right now, and if not, exactly what is wrong: closed surface or not, consistent winding, positive volume, whether the extents are real metres or a unit box. Four verdicts, free, keyless, and the specification is CC0 so anyone can implement it.+**Manufacturing.** A generated model can be printed in resin, nylon, colour sandstone, or steel and shipped, with a free printability report before any price (closed solid, separate bodies, hole locations, thinnest wall, exact volume, and a 0 to 100 score with named deductions), a safety screen that refuses weapons, key duplicates, and third-party brand marks, a certificate of authenticity in the box, and optional limited editions.-**Avatar Studio can now dress, rig, and walk an avatar,** not just paint it, and animation is universal: any humanoid skeleton drives the clip library, with bone-name mapping for the Mixamo, Avaturn, Unreal, VRM, Daz, MakeHuman and Blender conventions rather than a curated allowlist.+**Avatar Studio can dress, rig, and walk an avatar,** not just paint it. Alongside it: a restyling studio, a scene editor, pose and diorama tools, and an animation gallery the community authors into.-**Manufacturing.** A generated model can be printed in resin, nylon, colour sandstone, or steel and shipped, with a free printability report (closed solid, separate bodies, hole locations, thinnest wall, exact volume, and a 0 to 100 score with named deductions) before any price is quoted, a safety screen that refuses weapons, key duplicates, and third-party brand marks, and a certificate of authenticity in the box.+**Health checks that ask the right question.** An audit found twelve armed autonomous agents, all `Ready`, all enabled, ten of which had not attempted an action in weeks. Liveness measures the process; acting needs a chain of preconditions the process knows nothing about. We now model preconditions as vitals with `needs` edges and return the **root** blocker instead of a symptom. The engine is a zero-dependency, framework-agnostic package, and if you run an agent fleet on any stack I would suggest stealing the idea.-**Health checks that ask the right question.** An audit found twelve armed autonomous agents, all `Ready`, all enabled, ten of which had not attempted an action in weeks. Liveness measures the process; acting needs a chain of preconditions the process knows nothing about. We now model preconditions as vitals with `needs` edges and return the *root* blocker instead of a symptom. The engine is a zero-dependency package, framework-agnostic, and if you run an agent fleet on any stack I would suggest stealing the idea.+**Reliability, published.** A "brownout" layer that reports where a response's data came from and how fresh it is, and publishes **proven** fallbacks rather than promised ones. A failover path nobody has exercised under load is a hypothesis, not a fallback.-**Your terminal.** `npx @three-ws/tty-avatar <id>` draws any avatar in colour at 24fps in a plain terminal with no browser and no GPU. Wire it to a coding agent's hooks and the avatar becomes that agent's face: thinking, nodding while it edits, shaking when a tool fails, bouncing when it finishes.+**Testing.** A recorder that compiles a real user session into a Playwright spec which is red while the bug exists and green once it is fixed. A bug report is an experiment somebody else has to reconstruct, and the reconstruction is the part a machine can do.-**And the platform generally.** 128 new public pages since the start of August, a documentation sweep that re-checked 164 docs against the code they describe, and a performance pass on every page.+**Surfaces beyond the browser.** A terminal renderer (`npx @three-ws/tty-avatar <id>` draws any avatar in colour at 24fps with no browser and no GPU, and can become your coding agent's face), glance cards that put an agent's live status on a Windows 11 widget board, a GitHub README, or a Slack message, an Android app live on the Solana dApp Store, an iOS shell in the repo and not yet submitted, and a car surface whose Android Auto app is compiled and whose CarPlay scene waits on Apple's entitlement.++**And the platform generally.** 128 new public pages since the start of August, a documentation sweep that re-checked 164 docs against the code they describe, and a performance pass across every page.----## 6. The group, and what is next here+## 8. The group, and what is next here-For anyone new: this group has a real history. The first in-world meetup was held entirely inside a 3D world rather than on a call, with a peak of 3,145 avatars in the world across the day, a live platform tour, community demos, and open Q&A that included the two open-source watsonx.ai and Granite connectors. The recap is on the group blog.+For anyone new: this group has a real history. The first in-world meetup was held entirely inside a 3D world rather than on a call, with a peak of 3,145 avatars in the world across the day, a live platform tour, community demos, and open Q&A that included the two open-source watsonx.ai and Granite connectors. The recap is on the group blog, and the thread index carries the deeper technical background, including walkthroughs of the Forge, auto-rigging, and the `agent-3d` web component.IBM has indicated readiness to host a second event. The proposal on our side is a one-week open creation contest entered with a single sentence and no account, closing with a crowning ceremony inside the world. No date is set; that is the first decision to make, and this group is the right place to make it. If you have a format preference, say so in the comments.----## 7. One note on metering, for callers with no IBM Cloud account+## 9. One note on metering, for callers with no IBM Cloud accountScoped deliberately, because it is the one question we get from agent developers that the rest of this post does not answer.-A normal MCP server wrapping a hosted model forces every caller to bring their own provider account, key, and billing relationship. That is fine for a developer and fatal for an autonomous agent, which cannot sign up for anything mid-task. Our metered suite inverts it: the operator holds the watsonx.ai credentials and funds inference, and the caller settles a few cents per call from a wallet it already controls, using the HTTP 402 status code as the handshake. Granite becomes a metered utility that an agent can consume the moment it can pay.+A normal MCP server wrapping a hosted model forces every caller to bring their own provider account, key, and billing relationship. That is fine for a developer and fatal for an autonomous agent, which cannot sign up for anything mid-task. Our metered suite inverts it: the operator holds the watsonx.ai credentials and funds inference, and the caller settles a few cents per call from a wallet it already controls, using the HTTP 402 status code as the handshake. Granite becomes a metered utility an agent can consume the moment it can pay.++| | Credentials connector | Metered suite |+|---|---|---|+| Who pays IBM | The caller, with their own key | The operator, with one shared key |+| Caller needs an IBM Cloud account | Yes | No |+| Caller pays per call | No, flat IBM billing | Yes |+| Best for | A developer wiring watsonx.ai into their own client | An agent that wants Granite on demand |-The credentials connector and the metered suite are separate packages on purpose, and the credentials path (your key, your IBM billing, no metering) remains the right choice for a developer wiring watsonx.ai into their own client.+The two are separate packages on purpose. The credentials path remains the right choice for a developer.----## 8. Affiliations and listings, stated plainly+## 10. Affiliations and listings, stated plainlySince this post touches several vendor surfaces, here is the complete and precise position, with no upgrades:-- **IBM**: Business Partner. Everything under `/api/ibm/*` and the connector are independent developer tools on publicly available Granite models, not IBM products, not partnership deliverables, not endorsed by IBM.+- **IBM**: Business Partner. Everything under `/api/ibm/*` and the connector are independent developer tools on publicly available Granite models: not IBM products, not partnership deliverables, not endorsed by IBM.- **OpenAI**: Select Partner in the OpenAI Partner Network. A partner designation, not an endorsement.- **AWS**: AWS Partner. The Marketplace SaaS integration is built and deployed; the listing is not yet public.-- **Google Cloud**: member of Google Cloud for Web3 Startups. Production runs on Cloud Run, and the GPU workers run there too.-- **NVIDIA**: Inception member since July 2026. A startup program, not a partnership or an endorsement.-- **Alibaba Cloud**: listed on the Alibaba Cloud International Marketplace, with Qwen models available as lanes in the model router.+- **Google Cloud**: member of Google Cloud for Web3 Startups. Production and the GPU fleet run on Cloud Run.+- **NVIDIA**: Inception member since July 2026. A startup programme, not a partnership and not an endorsement.+- **Alibaba Cloud**: listed on the Alibaba Cloud International Marketplace, with Qwen models as lanes in the model router.- **Quicknode**: accepted into the Startup Program, July 2026.- **HackerNoon**: publishing partner; our announcements auto-import from our RSS feed.+- **Solana Mobile**: the Android app is live on the dApp Store; the iOS app is in the repo and not submitted.---@@ -203,6 +339,11 @@ curl -s https://three.ws/api/guardian/assess \-H 'content-type: application/json' \-d '{"text":"Turn off the hallway light","risks":["harm","unethical_behavior"]}'+# Granite embedding vectors for your own semantic search+curl -s https://three.ws/api/watsonx/embed \+ -H 'content-type: application/json' \+ -d '{"texts":["a witty trading assistant","a calm meditation guide"]}'+# is this 3D asset usable in a physics engine?curl "https://three.ws/api/sim-readiness?src=https://three.ws/avatars/cesium-man.glb"@@ -214,4 +355,4 @@ curl -s https://three.ws/api/mcp-studio \Source is Apache-2.0 at [github.com/nirholas/three.ws](https://github.com/nirholas/three.ws); the docs index is at [three.ws/docs](https://three.ws/docs); the IBM integration reference is at [three.ws/docs/ibm](https://three.ws/docs/ibm).-The question I would most like this group to argue about: **is a classifier the right shape for an action veto at all?** Guardian works well and the hash-chained ledger makes it auditable, but a probability threshold is a strange thing to have between an agent and a deadbolt. The alternative is a capability model where the dangerous verbs simply are not reachable, and we implemented that too, in the household roles. My current position is that you need both and that neither is sufficient. I would like to be talked out of half of that.+The question I would most like this group to argue about: **is a classifier the right shape for an action veto at all?** Guardian works well and the hash-chained ledger makes it auditable, but a probability threshold is a strange thing to have between an agent and a deadbolt. The alternative is a capability model where the dangerous verbs simply are not reachable, and we implemented that too, in the household roles. My current position is that you need both, that the classifier catches what the capability model did not anticipate, and that neither is sufficient alone. I would like to be talked out of half of that.diff --git a/docs/openai-community-physical-world-post.md b/docs/openai-community-physical-world-post.mdindex 636054650..09df15559 100644--- a/docs/openai-community-physical-world-post.md+++ b/docs/openai-community-physical-world-post.md@@ -4,7 +4,7 @@ venue: OpenAI Developer Community (community.openai.com)account: nichxbtcategory: API (Apps SDK / Actions / MCP)tags: [chatgpt, apps-sdk, mcp, actions, 3d, agents]-description: "A long technical follow-up on the three.ws 3D Studio connector: the eleven keyless MCP tools, the twelve surfaces we added on top of them, and what building tools that spend money and touch physical objects taught us about tool design."+description: "A long technical follow-up on the three.ws 3D Studio connector: the eleven keyless MCP tools, the surfaces we built on top of them, the 72-server MCP fleet behind them, and what building tools that spend money and touch physical objects taught us about tool design."status: draft, not yet posted---@@ -21,11 +21,29 @@ This is the follow-up, and it is a different kind of post. The interesting probl- What happens when a tool spends the user's money?- What happens when a tool moves an object in the physical world, like a printer or a deadbolt?- What does an agent do with a `.glb` URL it cannot see?-- How do you tell an agent that a tool it wants is temporarily degraded rather than broken?--We now have shipped answers to all four, and I want to write them down properly, because I could not find them written down anywhere when I needed them. Everything below is open source (Apache-2.0) and readable at [github.com/nirholas/three.ws](https://github.com/nirholas/three.ws).--**Short version:** the free connector is still eleven tools and still keyless. On top of it we added a vision tool so the model can look at its own output, a physics grade so a simulator knows if an asset is usable, a manufacturing API so an agent can order a physical print of what it just generated, a home-control MCP server whose dangerous tools refuse over stdio by design, and a set of health primitives that answer "can this agent act right now" instead of "is the process up".+- How do you tell an agent that a tool it wants is degraded rather than broken?+- And once you have fifty tool servers, how does anything discover the right one?++We have shipped answers to all five, and I want to write them down properly, because I could not find them written down anywhere when I needed them. Everything below is open source (Apache-2.0) and readable at [github.com/nirholas/three.ws](https://github.com/nirholas/three.ws).++**Short version:** the free connector is still eleven tools and still keyless. On top of it we added a vision tool so the model can look at its own output, a physics grade so a simulator knows if an asset is usable, a manufacturing API so an agent can order a physical print of what it just generated, a home-control MCP server whose dangerous tools refuse over stdio by design, an open CC0 response shape for 3D results, and a set of health primitives that answer "can this agent act right now" instead of "is the process up". Behind all of it sits 72 MCP servers in the official registry and 91 npm packages, which is its own design problem and gets its own section.++**Contents**++1. Where things stand on the two ChatGPT surfaces+2. Tools that are not free and not reversible+3. `look_at_model`: the agent could not see its own output+4. Simulation readiness: a grade a physics engine can act on+5. Materialize: when the tool call ends in a cardboard box+6. `home-mcp`: the tool that refuses over stdio+7. Spatial MCP: a 3D scene should not be a URL in a text block+8. "Can it act?" is not "is it up?"+9. Where the model goes after the chat: embedding, and the animation problem+10. The fleet problem: 72 servers, and how a client is supposed to find one+11. Your coding agent has a face now+12. The whole surface, in tables+13. Affiliations, stated precisely+14. What I would like this forum's opinion on---@@ -33,7 +51,7 @@ We now have shipped answers to all four, and I want to write them down properly,### The connector (Apps SDK / MCP)-`https://three.ws/api/mcp-studio`, Streamable HTTP, MCP protocol `2025-06-18`, no auth. It is deliberately scoped to 3D only: no wallet, no payments, no token, nothing a reviewer has to think twice about. Ask it what it has:+`https://three.ws/api/mcp-studio`, Streamable HTTP, MCP protocol `2025-06-18`, no auth. It is deliberately scoped to 3D only: no wallet, no payments, no token, nothing a reviewer has to think twice about. `GET` is intentionally not offered (there is no server-initiated stream), every request is answered synchronously over `POST`, and `OPTIONS` is handled for CORS. Ask it what it has:```bashcurl -s https://three.ws/api/mcp-studio \@@ -46,22 +64,24 @@ Eleven tools, as of today:| Tool | What it does ||---|---|| `forge_free` | text to a textured GLB |-| `text_to_avatar` | text to a rigged humanoid, skinned, with ARKit blendshapes |+| `text_to_avatar` | text to a rigged humanoid, skinned, with 52 ARKit blendshapes || `mesh_forge` | image or sketch to a mesh || `rig_mesh` | add a humanoid skeleton to a static GLB you already have || `forge_avatar` | photo to avatar |-| `refine_model` | iterate on a previous result; every refinement is its own version |+| `refine_model` | iterate on a previous result; every refinement is its own version with its own AR link || `check_job` | collect a generation that outran the tool call || `look_at_model` | render a model to images the assistant can actually see (section 3) |-| `create_agent_persona` / `get_agent_persona` / `persona_say` | give a rigged body a name, a voice line, and a living page |+| `create_agent_persona` | give a rigged body a name and a personality |+| `get_agent_persona` | read one back |+| `persona_say` | make it say a line, with real lipsync, on a living page |-Each generation tool renders inline through an Apps SDK widget with a rotatable viewer and a **View in your space** button for AR. If the result is rigged, the button becomes **Bring it to life**.+Each generation tool renders inline through an Apps SDK widget (`ui://widget/three-studio-model.html`) with a rotatable viewer and a **View in your space** button for AR. If the result is rigged, the response also carries an `irlUrl` and the button becomes **Bring it to life**. The persona tools render in their own widget (`ui://widget/three-studio-persona.html`).-The one production gotcha from the original post is still the single most common failure I get asked about, so I will repeat it: **the widget's `openai/widgetCSP` allowlist must include the origin your GLB is served from.** Real ChatGPT enforces that CSP. A widget that renders in a permissive local harness and shows a blank viewer in production is almost always this, and there is no console error you will see from the outside.+The one production gotcha from the original post is still the most common failure I get asked about, so I will repeat it: **the widget's `openai/widgetCSP` allowlist must include the origin your GLB is served from.** Real ChatGPT enforces that CSP. A widget that renders in a permissive local harness and shows a blank viewer in production is almost always this, and there is no console error you will see from the outside.### The custom GPT (Actions)-Same free lane as plain REST, for people whose plan does not do connectors. OpenAPI 3.1 served at `https://three.ws/.well-known/3d-studio-openapi.yaml`, imported by URL rather than pasted inline.+Same free lane as plain REST, for people whose plan does not do connectors. OpenAPI 3.1 served at `https://three.ws/.well-known/3d-studio-openapi.yaml`, imported by URL rather than pasted inline (pasting means the GPT builder holds a snapshot that silently drifts from the contract you actually serve).```bashcurl -s -X POST https://three.ws/api/3d/studio \@@ -69,7 +89,9 @@ curl -s -X POST https://three.ws/api/3d/studio \-d '{"prompt":"a small ceramic robot figurine"}'```-Submit never blocks. It answers `pending` with a `poll` path, an `etaSeconds`, a `watchUrl` the user can open, and (because our text-to-3D path goes through an intermediate image) frequently a `previewImageUrl` of the concept art the geometry model is about to sculpt. The GPT shows that image while it waits. It is a cheap trick and it makes the minute feel like fifteen seconds.+Submit never blocks. It answers `pending` with a `poll` path that already carries the job handle and title, an `etaSeconds`, a `watchUrl` the user can open (it shows the concept art and a real countdown and opens the finished model by itself), and frequently a `previewImageUrl`, because our text-to-3D path goes through an intermediate image and there is no reason to hide it. The GPT shows that image as markdown while it waits. It is a cheap trick and it makes the minute feel like fifteen seconds.++The poll endpoint returns `429` with a `retry_after` if the model polls too fast, and the GPT's instructions tell it to honour that rather than to tell the user something broke. That one line removed most of our "it says it failed but the model arrived" reports.---@@ -77,15 +99,17 @@ Submit never blocks. It answers `pending` with a `poll` path, an `etaSeconds`, aA read-only tool has one failure mode: it returns nothing useful. A tool that spends money or moves matter has a completely different risk surface, and MCP's annotation vocabulary (`readOnlyHint`, `destructiveHint`, `openWorldHint`) is necessary but nowhere near sufficient. Annotations tell the client what a tool is. They do not stop the tool.-We ended up with three rules, each learned the hard way.+We ended up with four rules, each learned the hard way.-**Rule 1: the refusal has to live on the server, not in the prompt.** Any guard that exists only as instruction text is a guard an assistant can be argued out of. In our smart home tools, a household member with the `guest` role cannot approve unlocking a door. Not "the UI hides the button": the server refuses the call, so there is no version of any client, ours or yours, that could offer it. When we scoped the household roles we wrote the refusal into the API first and the interface second, on purpose.+**Rule 1: the refusal lives on the server, not in the prompt.** Any guard that exists only as instruction text is a guard an assistant can be argued out of. In our smart home tools, a household member with the `guest` role cannot approve unlocking a door. Not "the UI hides the button": the server refuses, so no client, ours or anyone else's, could offer it. We wrote the refusal into the API first and the interface second, deliberately.**Rule 2: charge nothing until the refusal has run.** Our [Knock](https://three.ws/knock) surface lets someone pay to get one message to a stranger. Price, daily cap, message length limit, and block list are all evaluated **before** any payment is attempted, so a knock that was never going to land is never a knock somebody paid for. Sequencing the check after the charge is the natural way to write it and it is wrong.**Rule 3: a tool that makes a physical object needs a content gate that is allowed to say no.** Our [Materialize](https://three.ws/materialize) lane turns a generated model into a real printed object shipped to an address. It screens and refuses weapons, functional key duplicates, and third-party brand marks before anything reaches production. A print bureau has a human at that checkpoint. An API where an agent is the buyer does not, so the checkpoint has to be code.-If you are shipping a plugin whose tools cost the user money, the OpenAI review guidelines on deceptive commerce are worth reading as a design spec rather than a compliance checklist. The rule that matters in practice: never present a call as free and then charge for it. Our paid tools live on a completely separate server from the free ones, and the free server has no payment surface at all to get confused about.+**Rule 4: keep the free surface and the paid surface on different servers.** Not a flag, not a scope: different origins with different code. Our free 3D server has no payment code in it at all. Not disabled, absent. A reviewer can verify that in a minute, and so can we, forever. The paid sibling lives at `/api/mcp-3d` and shares none of the free server's surface.++If you are shipping a plugin whose tools cost the user money, the OpenAI review guidelines on deceptive commerce are worth reading as a design spec rather than a compliance checklist. The rule that matters in practice: never present a call as free and then charge for it.---@@ -97,7 +121,13 @@ That is the reason agentic 3D stalls after one shot: there is no feedback signal`look_at_model` renders the model from several angles and returns the frames as **MCP image content blocks**, so a multimodal client renders them straight into the conversation and the model looks at the thing it made. Alongside the frames it returns geometry facts (triangle count, bounds, material count, whether it is skinned) and a plain-language reading of them.-The loop this unlocks is the whole point: generate, look, judge, call `refine_model`, look again. Same over plain HTTP if you are not in an MCP client:+Three ways in, depending on what you are:++| You are | Use | You get |+|---|---|---|+| An MCP client | tool `look_at_model` on `/api/mcp-studio` | frames as MCP image blocks, rendered inline |+| A Node program | [`@three-ws/see`](https://www.npmjs.com/package/@three-ws/see) | `see(url)` gives views, stats, notes |+| Anything with HTTP | `POST /api/3d/look` | JSON with a frame URL per angle |```bashcurl -s -X POST https://three.ws/api/3d/look \@@ -105,6 +135,10 @@ curl -s -X POST https://three.ws/api/3d/look \-d '{"src":"https://three.ws/avatars/cesium-man.glb"}'```+The loop this unlocks is the whole point: generate, look, judge, call `refine_model`, look again. If you take one idea from this post, take this one: **any tool that hands an agent a binary is a tool that needs a companion that renders it into the agent's own modality.** Ours was 3D. Yours might be a PDF, a spreadsheet, a waveform, a CAD file.++A neighbour of this that came from the same insight: [`@three-ws/glb-diff`](https://www.npmjs.com/package/@three-ws/glb-diff) and the [Model Diff](https://three.ws/diff) page, which answer "what actually changed between these two versions of the mesh" structurally rather than by eyeballing two viewers. An agent iterating on an asset needs to know whether its last edit did anything.+---## 4. Simulation readiness: a grade a physics engine can act on@@ -117,16 +151,28 @@ So we published a grade, free and keyless:curl "https://three.ws/api/sim-readiness?src=https://three.ws/avatars/cesium-man.glb"```+```jsonc+{+ "verdict": "simulation_ready",+ "blockers": [],+ "warnings": ["skinned_geometry_graded_at_bind_pose"],+ "grader": "threews.sim.readiness.v1",+ "glbSha256": "b7001eaeea8254bd…"+}+```+Four verdicts, and the distinction between the middle two is the useful part:-| Verdict | Meaning |-|---|---|-| `simulation_ready` | Closed surface, consistent winding, positive volume, real-world extents. Use the reported mass. |-| `needs_scale` | Geometry is sound, only the units are missing. Multiply and go. |-| `needs_repair` | Open, non-manifold, or inconsistently wound. Mass properties are reported but not trustworthy. |-| `unusable` | No triangles, or zero volume. |+| Verdict | Meaning | What you do |+|---|---|---|+| `simulation_ready` | Closed surface, consistent winding, positive volume, real-world extents | Use it as a rigid body, and trust the reported mass |+| `needs_scale` | Geometry is sound, only the units are missing | Multiply to the intended size; mass properties scale with it |+| `needs_repair` | Open, non-manifold, or inconsistently wound | Close the surface first; do not trust the mass |+| `unusable` | No triangles, or zero volume | Reject it |++There is a fifth value, `unreadable`, for bytes that are not binary glTF 2.0 at all, kept deliberately distinct from `unusable`: one is a broken file, the other is a valid file with nothing to simulate.-The spec is CC0 ([`specs/SIM_READINESS.md`](https://github.com/nirholas/three.ws/blob/main/specs/SIM_READINESS.md)) and the grader is a pure function you can vendor. It is also a free tool (`grade_sim_readiness`) on our paid 3D MCP server, permanently free on purpose: an assurance check that costs money is a check nobody runs, and a check nobody runs prevents nothing.+The grade is content-addressed by the GLB's SHA-256, so the same bytes always get the same verdict and the result caches cleanly. The spec is CC0 ([`specs/SIM_READINESS.md`](https://github.com/nirholas/three.ws/blob/main/specs/SIM_READINESS.md)) and the grader is a pure function you can vendor. It is also permanently free as a tool (`grade_sim_readiness`) on our **paid** MCP server, which is a deliberate exception: an assurance check that costs money is a check nobody runs, and a check nobody runs prevents nothing.If you are building anything where an LLM produces assets for a simulator, a game engine, or a robotics stack, please steal this idea even if you never touch our endpoint. The absence of a machine-readable claim about physical usability is a real hole in the glTF ecosystem.@@ -136,23 +182,38 @@ If you are building anything where an LLM produces assets for a simulator, a gam[Materialize](https://three.ws/materialize) is the physical lane. Describe an object, generate it, then have it printed in resin, nylon, colour sandstone, or steel and shipped. The whole loop is also an API, which means an autonomous agent can order a physical object of a model it just generated with no human in the loop.-The pipeline, and the reasons each stage exists:+```+ a forge creation a GLB you upload an agent+ │ │ │+ └───────────────┬───────────┴───────────────────────────┘+ ▼+ POST /api/print/quote printability report + itemized price+ │ + a signed quote token (24 hours)+ ▼+ POST /api/print/orders human checkout+ POST /api/x402/print-order agent checkout, same pipeline+ ▼+ safety screening ──▶ production ──▶ quality check ──▶ shipped+ ▼+ certificate of authenticity, QR in the box+```-1. **Analysis, free and keyless.** `POST /api/print/quote` with a model returns a printability report before any price: is the mesh a closed solid, how many separate bodies, where the holes are, thinnest wall, exact volume, and a 0 to 100 score with named deductions written in plain language. Free because an agent that can check printability before paying to generate spends less overall.-2. **A signed quote token**, valid 24 hours, so the price an agent was quoted is the price it pays.-3. **Checkout, two ways.** A human pays in the browser; an agent pays over HTTP 402 against the same pipeline. Same order, same statuses.-4. **Safety screening**, described above, before production.-5. **A certificate of authenticity** attested on-chain, with a QR code in the box, so the object can prove which generation produced it. Limited editions can cap how many copies of a model will ever exist.+1. **Analysis, free and keyless.** `POST /api/print/quote` with a model returns the printability report before any price: whether the mesh is a closed solid, how many separate bodies it contains, where its holes are, its thinnest wall, its exact volume, and a 0 to 100 score with named deductions written for a person, not a slicer. Free because an agent that can check printability before paying to generate spends less overall.+2. **A signed quote token**, valid 24 hours, so the price an agent was quoted is the price it pays and nothing in between can move it.+3. **Two checkouts, one pipeline.** A human pays in the browser; an agent pays over HTTP 402. Same order record, same statuses, same fulfillment.+4. **Safety screening** before production, as described above.+5. **Provenance in the box.** Every print ships with a certificate of authenticity, attested publicly, with a QR code, so the object can prove which generation produced it. Creators can cap how many copies of a model will ever exist.+6. **Order tracking at every step**, because "the agent bought something and nobody can say where it is" is not a shippable state.-The design lesson for tool authors: **an irreversible tool needs a free, honest dry run in front of it.** Quote is free, detailed, and refusable. Order is the only call that costs anything, and by then every question has already been answered.+The design lesson for tool authors: **an irreversible tool needs a free, honest dry run in front of it.** Quote is free, detailed, and refusable. Order is the only call that costs anything, and by then every question has already been asked and answered by a machine that could still change its mind.---## 6. `home-mcp`: the tool that refuses over stdio-This is the surface I would most like feedback on from this forum, because I think the pattern generalises.+This is the surface I would most like feedback on, because I think the pattern generalises past homes.-[three.ws Home](https://three.ws/smart-home) connects an agent to a real house through [Home Assistant](https://www.home-assistant.io), which already owns the device layer (1,500-plus integrations, every protocol we would otherwise have to implement) and speaks MCP natively. We wrote no device code at all. What we added is the part nobody ships: a 3D presence that stands in a live model of your home, reacts to it, and talks to you.+[three.ws Home](https://three.ws/smart-home) connects an agent to a real house through [Home Assistant](https://www.home-assistant.io), which already owns the device layer (1,500-plus integrations, every protocol we would otherwise implement, around 90k stars) and speaks MCP natively. We wrote no device code at all. What we added is the part nobody ships: a 3D presence that stands in a live model of your home, reacts to it, and talks to you.We also published [`@three-ws/home-mcp`](https://www.npmjs.com/package/@three-ws/home-mcp), five tools that let any MCP assistant read the house, list entities, list the scenes the household already built, run one, and call a service:@@ -163,76 +224,180 @@ claude mcp add home \-- npx -y @three-ws/home-mcp```-Every call that would open the house goes through a physical-action gate, and **over stdio that gate refuses**. Not "prompts". Refuses. The reasoning: a stdio MCP server has no user-visible surface of its own, no session, and no way to prove that a human saw the request and approved it. Anything that presents itself as consent in that environment is a fiction. So unlocking is only available on the surfaces where a real person can be shown a real prompt, and the local server tells the assistant plainly that it will not do it and why.+Every call that would open the house passes through a physical-action gate, and **over stdio that gate refuses**. Not "prompts". Refuses. The reasoning: a stdio MCP server has no user-visible surface of its own, no session, and no way to prove that a human saw the request and approved it. Anything that presents itself as consent in that environment is a fiction. So unlocking is only available on surfaces where a real person can be shown a real prompt, and the local server tells the assistant plainly that it will not do it and why. The gate has one implementation shared with [`@three-ws/home-bridge`](https://www.npmjs.com/package/@three-ws/home-bridge) rather than a second copy that can drift.-Adjacent decisions from the same wave, since they are all about the same trust question:+Adjacent decisions from the same wave, since they are all the same trust question:-- **Households and roles.** Five roles, each stating in plain words at the moment you pick it what it can and cannot do. A guest can turn on the lights and can never approve unlocking anything. Scoped guests receive only the rooms they were given; the others are removed from the payload rather than hidden in the UI, so their client never learns those rooms exist. Removing a person revokes every standing allowance they ever approved, in the same instant.-- **A relay for houses with no public address**, which is the default Home Assistant install. The house dials us over one outgoing WebSocket; we never dial the house, no port is forwarded, and **we never receive a Home Assistant token**: the integration mints its own credential locally and it never leaves the building. Threat model is published.-- **Voice.** Hands-free in a kitchen, with an explicit design rule that a background "yeah" can never approve a lock. Confirmation for a physical action requires an intentional utterance, not an affirmative-sounding noise.-- **We tried making the agent a Matter device, measured it, and decided against it for now**, and published that negative result rather than quietly dropping it.+- **Households and five roles**, each stating in plain language, at the moment you pick it, what it can and cannot do. A guest can turn on lights and can never approve unlocking anything. Scoped guests receive only the rooms they were given: the others are **removed from the payload**, not hidden in the UI, so their client never learns those rooms exist. Invitations work once, expire after a week, and can be withdrawn. Removing someone revokes every standing allowance they ever approved, in the same instant. Every action in the home log is attributed to the person who took it.+- **A relay for houses with no public address**, which is the default Home Assistant install. The house dials us over one outgoing WebSocket; we never dial the house, no port is forwarded, no tunnel daemon runs, and **we never receive a Home Assistant token**, because the integration mints its own credential locally and it never leaves the building. The threat model is published.+- **Voice**, hands-free, with an explicit rule that a background "yeah" can never approve a lock: confirmation for a physical action requires an intentional utterance, not an affirmative-sounding noise.+- **A Home Assistant voice satellite can wear the agent's face**, so the assistant already in the kitchen gets a body rather than a speaker grille.+- **Data**: see, export, and delete everything a connected home stores, on one page.+- **We evaluated exposing the agent as a Matter device, measured it, and decided against it for now**, and published the negative result instead of quietly dropping it.++The car surface came out of the same design ([three.ws Drive](https://three.ws/drive)), and it is worth a sentence here because it is a pure Apps-SDK-shaped constraint problem: in a car, voice is not one interface among several, it is the only one that is legal. iOS 26.4 added a CarPlay category for voice-based conversational apps with its own entitlement, and iOS 27 let the Voice Control template overlay other templates. What Apple does **not** give a conversational app is a drawing surface, so the honest architecture is a voice-first agent whose control surface is Apple's templates and whose face lives on the phone in the cradle, the passenger display, or an open head unit. The Android Auto car app is written and compiled; the CarPlay scene is written and waiting on Apple's entitlement grant.----## 7. "Can it act?" is not the same question as "is it up?"+## 7. Spatial MCP: a 3D scene should not be a URL in a text block++A tool that returns a 3D result today returns a link. The client prints it. The user clicks it and leaves the conversation. That is the whole state of the art, and it is bad for exactly the same reason a chart returned as a URL would be bad.++[Spatial MCP](https://three.ws/spatial-mcp) is the open response shape we published for this: a renderer-agnostic, CC0 description of a 3D scene that an MCP client can render natively as a result, rather than a string containing an address. three.ws is the reference implementation, the validator and conformance fixtures are published as [`@three-ws/spatial-mcp`](https://www.npmjs.com/package/@three-ws/spatial-mcp), and the shape carries no payment, wallet, or token surface at all, because a wire format that smuggles commerce into it will never be adopted by anyone.++I would genuinely like other 3D tool authors here to adopt or fork it. A shared shape is worth more to all of us than our particular version of it.++---++## 8. "Can it act?" is not the same question as "is it up?"Every liveness check we had was correct, and none of them could tell us that ten of twelve armed autonomous agents had not attempted an action in weeks. The process was `Ready`, the feed was streaming, every row said `enabled = true`.-Three unrelated things were wrong: the deployed worker image predated the commit that moved the free model chain onto models that still exist, so the whole chain answered 404; the surviving providers were out of credit or on a billing hold; and several agent wallets could not fund a single action.+Three unrelated things were wrong: the deployed worker image predated the commit that moved the free model chain onto models that still exist, so the whole chain answered 404 and 410; the surviving providers were out of credit or on a billing hold; and several agent wallets could not fund a single action.++Liveness measures the process. Acting requires a chain of preconditions the process knows nothing about. So we built [agent vitals](https://three.ws/docs/agent-vitals): preconditions declared as **vitals** with `needs` edges, actions as **capabilities** that AND over them, and attestation that returns the **root** blocker rather than a symptom.++```+deploy-fresh ──> cognition ──┐+ ├──> [enter]+armed, solvency, feed, rpc ──┘++rpc ─────────────────────────────> [exit]+```++It is a framework-agnostic package with no dependencies ([`packages/agent-vitals`](https://github.com/nirholas/three.ws/tree/main/packages/agent-vitals)). Nothing about it is specific to our platform, and if you run an agent fleet I think you want something like it. "Healthy and structurally unable to work" will not show up in your existing metrics.++Two neighbours from the same problem:-Liveness measures the process. Acting requires a chain of preconditions the process knows nothing about. So we built [agent vitals](https://three.ws/docs/agent-vitals): preconditions declared as vitals with `needs` edges, actions as capabilities that AND over them, and attestation returns the **root** blocker rather than a symptom. It is a framework-agnostic package with no dependencies ([`packages/agent-vitals`](https://github.com/nirholas/three.ws/tree/main/packages/agent-vitals)); nothing about it is specific to our platform, and if you run an agent fleet I think you want something like it.+- [Brownout](https://three.ws/brownout) and [`@three-ws/brownout`](https://www.npmjs.com/package/@three-ws/brownout): read where an API's data came from and how fresh it is, and publish **proven** fallbacks rather than promised ones. A failover path nobody has exercised under load is a hypothesis, not a fallback.+- [x402 Preflight](https://three.ws/preflight) and [`@three-ws/x402-preflight`](https://www.npmjs.com/package/@three-ws/x402-preflight): ask a paid seller whether it can actually settle before signing anything.-Two neighbours from the same problem: [Brownout](https://three.ws/brownout), which publishes proven fallbacks rather than promised ones (a fallback nobody has exercised is not a fallback), and [x402 Preflight](https://three.ws/preflight), which answers whether a paid endpoint can actually settle before you send it anything.+And a third, which is a testing tool rather than a runtime one: [`@three-ws/witness`](https://www.npmjs.com/package/@three-ws/witness) records what a person actually did and compiles it into a Playwright spec that is **red while the bug exists and green once it is fixed**. A bug report is a description of an experiment somebody else has to reconstruct, the reconstruction is where most reports die, and it is the part a machine can do. It works on any site, with or without the rest of our stack.----## 8. The odd one: your coding agent has a face now+## 9. Where the model goes after the chat++A recurring question in the original thread was some version of "great, I generated a fox in ChatGPT, now what". The answer is the part of the platform that has nothing to do with OpenAI, and it is worth summarising because it is what makes the connector more than a toy.++**Embedding.** Every generated avatar is a web component. One tag on any page:++```html+<script type="module" src="https://three.ws/embed.js"></script>+<agent-3d agent="<id>"></agent-3d>+```-Not an OpenAI surface, but it is the thing developers in this community respond to most, so it belongs here. `npx @three-ws/tty-avatar <id>` draws any three.ws avatar in colour at 24fps in a plain terminal, no browser and no GPU, using truecolor half-blocks or braille cells.+There are also framework and use-case wrappers: [`@three-ws/react`](https://www.npmjs.com/package/@three-ws/react), an avatar overlay that reacts to buttons and navigation, a floating concierge chat widget, a page narrator that reads the page it lives on, a walk companion that roams a corner of the screen, and a guided tour agent. All of them are paste-in snippets with no backend on your side.-The second half is the point: wire it to a coding agent's hooks once, and the avatar becomes that agent's face. It looks up and thinks while the agent reads your prompt, nods while it edits, shakes when a tool fails, pulses when it is waiting on you, and bounces when it finishes, with a caption saying what it is doing right now. It turns out that an ambient face in a second pane is a much better progress indicator than a spinner, because you read its posture without switching focus.+**Animation, which is the part people underestimate.** A rigged model is useless if your clip library only fits one naming convention. Ours canonicalises bone names across Mixamo, Avaturn, Unreal, VRM and VRoid, VRM 1.0, Daz/Genesis, MakeHuman, Blender `.L`/`.R`, and simple `shoulderL` rigs, then retargets idle, walk and the rest onto whatever came in, legs included. There is **no rig allowlist**: a model that genuinely cannot be skeleton-driven falls back to a default rig rather than a bind-pose T-pose. That logic is published as [`@three-ws/retarget`](https://www.npmjs.com/package/@three-ws/retarget). If you have ever hand-mapped a skeleton, this is the package to steal.++**Delivery.** [`@three-ws/avatar-stream`](https://www.npmjs.com/package/@three-ws/avatar-stream) packs a GLB into a layered progressive stream over plain HTTP, so a heavy avatar shows something correct early instead of blocking on the whole file. [`@three-ws/render`](https://www.npmjs.com/package/@three-ws/render) renders rigged avatars to PNG, GIF, and truecolor terminal frames server-side, which is how the same agent shows up in a GitHub README, a Slack message, and a Windows 11 widget board.++**One command, if you want the whole thing scaffolded:**++```bash+npx @three-ws/create-agent+```++That goes from a sentence to a rigged, animated 3D agent you can embed.++**And the odd one out:** [Portal](https://three.ws/portal) turns any website into a walkable 3D world by reading the page's real structure, and exposes that shape over MCP. The reason it belongs in this post: an agent that fetches a page gets a wall of text, but over Portal it gets the page's *shape*, which is small enough to reason about and spatial enough to hand back as somewhere a human can actually go.++---++## 10. The fleet problem: 72 servers, and how a client is supposed to find one++This is the section I would have wanted to read a year ago.++As of a footprint audit on 2026-08-25, three.ws publishes **72 MCP servers in the official Model Context Protocol registry** under one namespace (`io.github.nirholas`), and **91 packages on npm** under `@three-ws`, 39 of which are MCP servers in this repository. That is not a brag, it is a confession: it is too many, and the reason it happened is instructive.++Every capability that felt independently useful became its own server, because a server is cheap to publish and MCP has no first-class notion of a namespace or a bundle. The result is a discovery problem that the registry alone does not solve, and every multi-server publisher I have talked to has it.++What we do about it, in the order we found it worked:++1. **One tightly scoped server per audience, not per capability.** The ChatGPT-facing server is exactly the 3D tools and nothing else. The plugin guidelines reward tightly scoped apps and reject generic ones, and thirty-seven separately submitted servers would read as directory spam even if each one were good. Submit one, document the rest as direct connections.+2. **One hosted server behind OAuth 2.1** (`https://three.ws/api/mcp`) that carries the whole platform for clients that want everything, with `/.well-known/oauth-protected-resource` discovery routed properly. Discovery metadata that 404s is the single most common reason an otherwise-correct server fails a client's auth handshake.+3. **Typed tool authoring, shared.** [`@three-ws/tool-sdk`](https://www.npmjs.com/package/@three-ws/tool-sdk) gives us `defineTool` and `defineExec` so annotations, schemas, and error shapes cannot drift server to server. Fifty servers written by hand will disagree about error shape by the third one.+4. **Publish where clients actually look.** The registry is necessary and not sufficient: 18 of ours are indexed on PulseMCP and 10 on Glama, a LobeHub plugin manifest is served from our own domain, and four Claude Code plugins ship from the repo's own marketplace.++If you are about to publish your fifth MCP server, my honest advice is to stop and ask whether it is a server or a tool namespace inside one. We answered that question late.----## 9. Everything, in one table+## 11. Your coding agent has a face now-Free and keyless unless marked. Paid surfaces settle per call over HTTP 402 and never appear on the free server.+Not an OpenAI surface, but it is the thing developers respond to most, so it belongs here. `npx @three-ws/tty-avatar <id>` draws any three.ws avatar in colour at 24fps in a plain terminal, no browser and no GPU, using truecolor half-blocks, braille cells (2x4 dots per cell for four times the vertical detail), or a plain luminance ramp when the output is piped.-| Surface | Where | Cost |+The second half is the point:++```bash+npx @three-ws/tty-avatar install-hooks --write+```++That merges hook entries into your coding agent's settings (leaving any you already have alone, and it is idempotent). Open two panes: viewer in one, agent in the other. The avatar looks up and thinks while the agent reads your prompt, nods while it edits and runs commands, shakes when a tool fails, pulses when it is waiting on you, and bounces when it finishes, with a caption saying what it is doing right now (`editing index.js`, `$ npm test`, `searching`).++An ambient face in a second pane turns out to be a much better progress indicator than a spinner, because you read its posture without switching focus. The renderer core is separately published as [`@three-ws/tty-3d`](https://www.npmjs.com/package/@three-ws/tty-3d) if you want to draw something else.++---++## 12. The whole surface, in tables++**Free and keyless.** Paste and run.++| What | Endpoint |+|---|---|+| 3D Studio MCP, 11 tools | `POST https://three.ws/api/mcp-studio` |+| 3D Studio Actions | `POST https://three.ws/api/3d/studio` |+| Look at a model | `POST https://three.ws/api/3d/look` |+| Simulation readiness | `GET https://three.ws/api/sim-readiness?src=…` |+| Printability report and quote | `POST https://three.ws/api/print/quote` |+| Live commit and revision of production | `GET https://three.ws/api/version` |++**Paid or gated**, on separate servers from the free ones.++| What | Where | Payment ||---|---|---|-| 3D Studio MCP (11 tools) | `POST https://three.ws/api/mcp-studio` | free |-| 3D Studio Actions | `POST https://three.ws/api/3d/studio` | free |-| Look at a model | `POST https://three.ws/api/3d/look` | free |-| Simulation readiness | `GET https://three.ws/api/sim-readiness` | free |-| Print quote and printability report | `POST https://three.ws/api/print/quote` | free |-| Print order | `POST https://three.ws/api/print/orders` (human), x402 (agent) | paid |-| Home control | [`@three-ws/home-mcp`](https://www.npmjs.com/package/@three-ws/home-mcp) | free, gated |-| Reach a person | [`@three-ws/knock-mcp`](https://www.npmjs.com/package/@three-ws/knock-mcp) | door owner sets the price |-| Full platform MCP (OAuth 2.1) | `https://three.ws/api/mcp` | mixed |-| Paid 3D studio | `https://three.ws/api/mcp-3d` | mixed, some tools free forever |+| Full platform MCP | `https://three.ws/api/mcp` | OAuth 2.1 |+| Paid 3D studio (rig, animate, retexture, analyse) | `https://three.ws/api/mcp-3d` | OAuth 2.1 or per call over HTTP 402 |+| Print order | `POST /api/print/orders` or the 402 lane | per order |+| Reach a person | [`@three-ws/knock-mcp`](https://www.npmjs.com/package/@three-ws/knock-mcp) | the door owner's price |+| Home control | [`@three-ws/home-mcp`](https://www.npmjs.com/package/@three-ws/home-mcp) | free, gated, refuses over stdio |++**The footprint behind it**, from an audit dated 2026-08-25 unless noted:++| | |+|---|---|+| npm packages under `@three-ws` | 91 in this repo (101 across the wider scope at audit time) |+| MCP servers in the official registry | 72, namespace `io.github.nirholas` |+| GPU and service workers | 32 in-repo, running open model families (Hunyuan3D, TRELLIS, TripoSG, TripoSR) plus rig, remesh, texture, segment, stylize, rembg, motion and vision lanes |+| Public pages | 795, of which 128 were added since 1 August 2026 |+| Specs | 31, including the CC0 Spatial MCP and simulation-readiness shapes |+| Test files | around 1,750 |-There are 39 MCP packages in the repo under `packages/*-mcp` and 32 GPU and service workers under `workers/`. The generation lanes run on open models (the Hunyuan3D, TRELLIS, TripoSG and TripoSR families) on our own GPU fleet, with a failover chain per lane so a single model being unavailable degrades quality rather than failing the request.+Every generation lane has a failover chain, so a single model being unavailable degrades quality rather than failing the request. `GET /api/version` returns the exact commit production is running, so you can check that what is deployed is what is on GitHub.----## 10. Affiliations, stated precisely+## 13. Affiliations, stated preciselyI would rather over-disclose than let a reader assume something wrong:-- **OpenAI**: three.ws is a **Select Partner in the OpenAI Partner Network**. That is a partner designation, not an endorsement, and three.ws is not an OpenAI product. The free connector is the surface submitted for the plugin directory; the ChatGPT app and the custom GPT are our own builds against public APIs.-- **IBM**: three.ws is an IBM Business Partner and agents can run on IBM Granite models served through watsonx.ai. Our public Granite-backed demo endpoints are independent developer tools, not IBM products and not endorsed by IBM.-- **AWS**: three.ws is an AWS Partner with a built and deployed Marketplace SaaS integration. The listing itself is not yet public, so there is nothing to subscribe to on the AWS side today.-- **Google Cloud**: member of Google Cloud for Web3 Startups. Production (the API, the frontend, and the GPU workers) runs on Cloud Run.-- **NVIDIA**: Inception member since July 2026. Membership is a startup program, not a partnership or an endorsement.-- **Alibaba Cloud**: the product is listed on the Alibaba Cloud International Marketplace, and Qwen models are lanes in our model router.+- **OpenAI**: three.ws is a **Select Partner in the OpenAI Partner Network**. That is a partner designation, not an endorsement, and three.ws is not an OpenAI product. The free connector is the surface submitted for the plugin directory; the ChatGPT app and the custom GPT are our own builds against public APIs. Our Cookbook PR is open and unmerged; I mention it because pretending otherwise would be silly.+- **IBM**: Business Partner. Agents can run on IBM Granite models served through watsonx.ai. Our public Granite-backed demo endpoints are independent developer tools, not IBM products, not endorsed by IBM.+- **AWS**: AWS Partner, with a built and deployed Marketplace SaaS integration. The listing itself is not yet public, so there is nothing to subscribe to on the AWS side today.+- **Google Cloud**: member of Google Cloud for Web3 Startups. Production (API, frontend, GPU workers) runs on Cloud Run, with Vertex AI in the model chain.+- **NVIDIA**: Inception member since July 2026. A startup programme, not a partnership or an endorsement.+- **Alibaba Cloud**: listed on the Alibaba Cloud International Marketplace, with Qwen models as lanes in the model router.+- **Solana Mobile**: the Android app is live on the Solana dApp Store. The iOS app exists in the repo and has not been submitted.----## 11. What I would like this forum's opinion on+## 14. What I would like this forum's opinion on-1. **Physical-action tools and MCP annotations.** `destructiveHint` covers "this deletes something". It does not distinguish "this spends $40" from "this unlocks a door in a house where a child is asleep". Is anyone modelling that distinction in a way clients could actually act on, or are we all inventing per-server gates?+1. **Physical-action tools and MCP annotations.** `destructiveHint` covers "this deletes something". It does not distinguish "this spends $40" from "this unlocks a door in a house where a child is asleep". Is anyone modelling that distinction in a way clients could act on, or are we all inventing per-server gates?2. **Consent in stdio MCP servers.** Our answer was to refuse outright. Is there a pattern where a stdio server can obtain provable human consent without pushing the user to a hosted surface?-3. **Long jobs in Actions.** Our submit-and-poll shape with `etaSeconds`, a `watchUrl` and a preview image works well, but every builder I know reinvents it. Is there appetite for a convention here?-4. **Asset feedback loops.** `look_at_model` was the single highest-leverage tool we shipped this year, and it exists only because a binary URL is useless to a model. What other formats does your agent hand back to itself blind?+3. **Long jobs in Actions.** Our submit-and-poll shape with `etaSeconds`, a `watchUrl`, a preview image, and an honoured `429 retry_after` works well, but every builder reinvents it. Is there appetite for a convention?+4. **Binary results.** `look_at_model` was the highest-leverage tool we shipped this year, and it exists only because a binary URL is useless to a model. What other formats does your agent hand back to itself blind?+5. **Fleet discovery.** If you publish more than a handful of MCP servers, how are you handling namespacing and discovery? I do not think the answer we arrived at is the right one, only the one that worked.Happy to answer anything about the internals. The whole stack is Apache-2.0 at [github.com/nirholas/three.ws](https://github.com/nirholas/three.ws), and the docs index is at [three.ws/docs](https://three.ws/docs).diff --git a/docs/three-thesis.md b/docs/three-thesis.mdindex 59a2b461d..414772df8 100644--- a/docs/three-thesis.md+++ b/docs/three-thesis.md@@ -502,7 +502,7 @@ The repository is silent on the following. Their absence is a fact, not a red fl- **No documented emissions to users.** The in-game economy is explicit that $THREE is never awarded by gameplay. Agora and the labor market pay $THREE, but from escrow funded by posters, not from inflation.- **No cumulative revenue, cumulative buyback USD, or holder count in the docs.** All of these are read live from public endpoints (`/api/three-token/stats`, `/revenue-share`, `/leaderboard`, `/agent-economy-volume`) rather than quoted in prose. That is the correct design, and it means the numbers in this document are a snapshot that the endpoints will outdate.-Questions worth asking: What is the treasury's current $THREE and USDC balance? When will `THREE_BUYBACK_ENABLED` and `THREE_MICROBUY_ENABLED` be flipped on? How is the deploy-burn ledger reconciled with the no-platform-burn policy? What is the team's own holding and is it locked?+Questions worth asking: What is the treasury's current $THREE and USDC balance? How is the deploy-burn ledger reconciled with the no-platform-burn policy? What is the team's own holding and is it locked?---