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(publishing): draft five CoinMarketCap niche articles and revise the community posts for the October run
nirholas8a1e5080f7b8
diff --git a/docs/aws-builder-center-agent-commerce-spine.md b/docs/aws-builder-center-agent-commerce-spine.mdindex 843d45793..778974fae 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, 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_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 that path looks like when the thing at the end of it is 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@@ -10,39 +10,44 @@ status: draft, not yet submitted# The agent bought a physical object: building an authorization spine for autonomous commerce-Most agent-commerce writing stops at the payment. A wallet signs, a transaction confirms, the demo ends. That is the easy half.+Imagine asking an AI agent to design a small desk figurine, and a little over a week later a nylon print of it arrives at your door, with a certificate in the box that says exactly which generation produced it. The agent found the model, checked that it could be printed, got a price, paid for it, and tracked the order, all on its own, inside a budget you set.-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?+That is a real flow at [three.ws](https://three.ws) today, and this article is about the part of it you do not see: the authorization layer that makes it safe to hand an agent that much autonomy.-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).+If you are new to agent commerce, here is the friendly version. When a person buys something online, a lot of quiet checks happen around the payment: who you are, what you are allowed to buy, whether it fits your budget, whether the seller can deliver, and a receipt at the end. An agent needs every one of those checks too, and it needs them to run in milliseconds, without a human clicking through a form. We call the chain of those checks the **authorization spine**, and every purchase on three.ws travels along it.-**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.+The questions it answers, in order: Who is this caller? What is it entitled to? Is this within the budget its owner set, and does that check hold when four of the owner's agents spend at once? Can the seller on the other end settle? What proves, afterwards, that the exchange happened? And when the thing being bought is a physical object that gets manufactured and shipped, what screens the order before production begins?++three.ws is 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 walks through the 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 confirms a seller can settle, the receipt layer that makes it auditable, the partners whose infrastructure carries it, and the physical fulfillment lane at the end. Every claim points at readable source in [our repository](https://github.com/nirholas/three.ws).++**Where things stand.** three.ws is an AWS Partner, and the AWS 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 Marketplace listing is coming: creating the product record in the AWS Marketplace Management Portal is the next step. Every other surface in this article is live today 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, under our membership in Google Cloud for Web3 Startups, so the two clouds each do what they do best for us.**Contents**1. Two economies, one authorization path-2. The AWS Marketplace half, and the part of it that is now wrong on the internet+2. The AWS Marketplace half, built on the current SaaS contract3. The agent half: a budget, not a credential4. Payment sessions: what "budget" looks like as an API-5. Preflight, re-quotes, and the failure paths that are the actual product+5. Preflight, re-quotes, and settlement assurance6. 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+7. Can this agent act? A health check built for agents+8. The end of the chain is an object in a box+9. The partners underneath the spine+10. What is open, and what you can lift from it+11. Design principles we carry forward+12. Try it without an AWS account---## 1. Two economies, one authorization path-We have two completely different kinds of buyer.+We serve two very different kinds of buyer, and both are a pleasure to design for.-An **enterprise buyer** wants procurement through the channel they already have: subscribe on AWS Marketplace, consolidate on the AWS invoice, let security review one vendor record. They want an API key and a contract.+An **enterprise buyer** wants procurement through the channel they already have: subscribe on AWS Marketplace, keep the vendor relationship in their AWS account, let security review one vendor record. They want an API key and a clear agreement.-An **agent buyer** cannot do any of that. It cannot sign up, cannot accept terms, cannot wait for a key to be provisioned by a human, and frequently does not exist as an entity that could hold a contract. It has a wallet and a task, and it needs the answer in the next few hundred milliseconds.+An **agent buyer** works differently. It has a wallet and a task, and it needs the answer in the next few hundred milliseconds. It does not sign up, accept terms, or wait for a key to be provisioned by a human, so its access has to be granted by protocol rather than by paperwork.-The mistake we avoided, barely, was building two access-control systems. What we built instead is one authorization check with two front doors:+We built one authorization check with two front doors:```AWS Marketplace subscription@@ -55,33 +60,44 @@ 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, 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.**+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 kept the product as one codebase, 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.+The billing model is worth describing precisely, because it is a little 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, so there is nothing to reconcile on the AWS invoice. We still implemented `MeterUsage`, `BatchMeterUsage`, and `GetEntitlements` against the SDK v3 clients, so a usage-priced dimension is a listing change rather than a re-architecture. Two environment switches already exist for that day: `AWS_MP_METERING_DIMENSION` reports `BatchMeterUsage` per granted call on a usage-based listing, and `AWS_MP_ENTITLEMENT_REQUIRED` gates key issuance on a live `GetEntitlements` check for a contract listing. Issued keys carry a rate limit (600 per minute by default), adjustable per offer.----## 2. The AWS Marketplace half, and the part of it that is now wrong on the internet+## 2. The AWS Marketplace half, built on the current SaaS contract++AWS refreshed the SaaS integration contract for new products, and building to the current shape from day one is the cleanest path. Here is what that shape looks like in practice.-If you implement a SaaS listing today by following the highest-ranked tutorials, you will implement the deprecated shape. This is worth getting on the record.+### `ResolveCustomer` returns a license ARN-### `ResolveCustomer` no longer returns what you think+For a **new** SaaS integration, `ResolveCustomer` returns `LicenseArn` and `CustomerAWSAccountId` ([API reference](https://docs.aws.amazon.com/marketplacemetering/latest/APIReference/API_ResolveCustomer.html)), and the license ARN is the per-grant identity.-For a **new** SaaS integration, `ResolveCustomer` does not populate `CustomerIdentifier`. It returns `LicenseArn` and `CustomerAWSAccountId` ([API reference](https://docs.aws.amazon.com/marketplacemetering/latest/APIReference/API_ResolveCustomer.html)). The license ARN is the per-grant identity.+This is a genuinely good change, because under **Concurrent Agreements** one AWS account can hold several simultaneous agreements for the same product. Keying every subscription on its license ARN is what lets one AWS account hold several agreements cleanly, which is exactly how larger organisations buy.-This 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 for lookups of older rows. If you are extending an existing integration, the move is additive: new columns and a backfill, with new rows keyed on the license ARN from day one.-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 the row's own id-### 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 exchange it, then redirect the browser to a welcome page carrying a handle, and that handle is **the row's own id**. The license ARN stays on the server, so a grant identifier never appears in browser history, referrer headers, proxy logs, or analytics.-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 arrive on EventBridge, and every path verifies++Agreement and license lifecycle notifications arrive as EventBridge events with `source: aws.agreement-marketplace`. Because EventBridge delivers to a seller account's event bus, an EventBridge rule targets an **API destination** that relays to our webhook, and `scripts/aws-marketplace-provision.sh` creates the connection, destination, IAM role, dead-letter queue, and rule in one go. EventBridge retries with backoff and dead-letters to SQS, so every delivery is recoverable.++| Event | Effect |+|---|---|+| `Purchase Agreement Created` / `Amended` | Record the agreement; open a pending record if the buyer has not registered yet |+| `License Updated` | Attach the license ARN to the buyer's record |+| `Purchase Agreement Ended` | Revoke the x402 key and mark the record cancelled |+| `License Deprovisioned` | Revoke the x402 key and mark the record cancelled |-### Lifecycle events moved to EventBridge, and the old path still has to verify+The relay authenticates with a shared secret the API destination attaches as a header, compared in constant time. Our webhook also accepts the legacy SNS notifications (`subscribe-success`, `unsubscribe-success`, `subscribe-fail`, `entitlement-updated`) with full signature verification that follows the message's `SignatureVersion`, and binds them to the AWS-issued topic for this product by pinning its ARN. Every path that can change authorization gets the same rigour. If you support both transports, write one handler with two adapters rather than two handlers, so the authorization consequences of an event are identical whichever way it arrives.-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.+One design detail we are particularly happy with: when an end event identifies only an AWS account, and that account holds more than one live agreement for the product, the webhook records the event precisely and revokes nothing, so a buyer's paid access always stays exactly as they bought it.-### The endpoints, and what refuses what+### The endpoints, and what each one answers| Endpoint | Purpose ||---|---|@@ -90,7 +106,7 @@ Agreement and license lifecycle notifications now arrive as EventBridge events.| `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 account:+`link` and `issue-key` both require an active session and both keep a subscription with the account it belongs to, so a given AWS subscription is attached to exactly one account:| Status | Meaning ||---|---|@@ -99,7 +115,7 @@ Agreement and license lifecycle notifications now arrive as EventBridge events.| `404 customer_not_found` | Unknown subscription record. Re-open the setup link from Marketplace. || `409 subscription_inactive` | Cancelled or expired. Re-subscribe first. |-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.+Returning the plaintext key once is a deliberate choice: it keeps the only readable copy of the key with its owner, where it belongs.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`.@@ -107,75 +123,84 @@ Code: [`api/aws-marketplace/`](https://github.com/nirholas/three.ws/tree/main/ap## 3. The agent half: a budget, not a credential-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.+When you give an agent buying power, the primitive we reach for is a **policy**, not a credential: a budget, a set of allowed counterparties, a per-call ceiling, and an expiry. A policy is bounded from the moment it exists. The agent acts under it on every spend, and the ceiling is enforced where concurrency cannot get around it.-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.+Three implementation details make it hold.-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, an unsuccessful attempt moves no funds: we release the reservation and mark the row accordingly. After settlement we mark it `completed` and attach the settlement signature, payer address, and result summary.-**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.** Each budget check is a single statement with its condition inline, so the check and the reservation are one atomic operation. That makes the budget race-free by construction, even with many agents spending from it at once.-**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.+**Only settled rows count.** Our public volume roll-up filters on `completed` in every aggregate, so "volume" means "money actually moved, signature on file", and that definition is applied identically to totals, counts, averages, leaderboards, and the feed. When the ledger has no rows yet, the endpoint returns a real zero shape and the page renders a designed empty state. If you are building a dashboard over an agent economy, deciding what a row means **before** you put a number on a page means every number you publish is one you can stand behind.-**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).+The framing we design against: **an autonomous spend has the same three properties as a database transaction.** Atomic (the check and the reservation are one operation), consistent (the ledger and the policy always agree), durable (every attempt is logged, whatever its outcome, so the whole history is auditable).---## 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.+A policy is most useful when 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. Its one-line summary is the whole philosophy: the agent does not hold a wallet; it proposes spend, and governance enforces policy.++An owner creates a session with a total budget, a per-transaction ceiling, an allowlist of hosts, and an expiry:++```json+{+ "budget_usd": 10.00,+ "label": "Research agent, June sprint",+ "expiry_seconds": 86400,+ "max_per_tx_usd": 0.50,+ "allowed_hosts": ["api.example.com", "data.provider.io"],+ "network": "solana"+}+```++The session token is shown once. The agent then calls `pay_with_session` with a URL and an `idempotency_key`, the platform wallet signs, and every call debits the session atomically on the server. The response carries the transaction hash, an explorer link, and the updated budget. When the budget is spent, the session declines further calls, and that is a normal, well-typed outcome the agent handles like any other result. `check_payment_session` and `list_payment_sessions` give the owner the full picture at any time.-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.+Because the interface is an MCP server, any client that speaks the Model Context Protocol gets these as ordinary tools. It drops into an Amazon Bedrock AgentCore agent, a Strands agent, a Claude Code session, or your own loop, without caring where the agent runs.-Two related packages, because different consumers want different ergonomics:+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/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 on its own.- [`@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.+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, building the 402 challenge and running the verify, dispatch, settle flow, with zero dependencies.----## 5. Preflight, re-quotes, and the failure paths that are the actual product+## 5. Preflight, re-quotes, and settlement assurance-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.+HTTP 402 as a protocol is elegant: a caller requests, gets a structured challenge with payment requirements, pays, and retries with proof. Around that core, we invested heavily in settlement assurance, the set of checks that keeps an agent economy predictable at scale.-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, an agent can confirm that the seller can settle: the challenge is well-formed, the receiving address is real, the declared chain and asset match what is being asked for, and the settlement path responds. 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)), so every paid call can start from a confirmed seller.-**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 has usually re-quoted between probe and replay. In that case the signed transfer is never broadcast, so no money has 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 records the retry distinctly in its logs so the pattern is visible. One bounded retry keeps spend predictable.-**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**, in addition to the per-call ceiling, so the total across a working day has a ceiling as well as each call.-**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.+**Log every decision with the same care.** Every autonomous call we make is recorded, with the challenge, the decision, and the outcome, so declined calls are as well documented as completed ones and the whole history reads cleanly.---## 6. Receipts: the part that makes it auditable a year later-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.+An entitlement answers "may this caller do this". A receipt answers "did this exchange actually happen, and can a third party check". Enterprise buyers value the second question, and we built the answer in from the start.-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.+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: **110,416 on-chain settlements and 803,483 verifications** at that same audit, with the implementation in the repo under `api/_lib/x402/`. USDC is the default settlement asset, and the smallest payment the facilitator settles is $0.001, which is what makes genuine per-call pricing practical. Discovery is a static, public catalog at `/.well-known/x402.json` listing **4,519 priced endpoints**, which is how an agent finds a seller in the first place.-Two lessons that transfer to any metered API, marketplace-billed or not:+Two principles that transfer to any metered API, marketplace-billed or not:-**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.+**Self-hosting the settlement path gives end-to-end visibility.** Every step from verification to on-chain settlement is code we run and can read, so we can trace any payment from challenge to signature, and our latency is ours to tune. Solana is our home chain and settlement runs on our own rail there.-**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.+**Discovery works best as a static document.** Ours is a file on our own domain: cacheable, diffable, readable by anything, and always available, which is exactly what you want sitting in the middle of a payment flow.----## 7. Can this agent act at all? A different health check--An 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.+## 7. Can this agent act? A health check built for agents-Three unrelated things were wrong, and none was visible to anything we measured. The deployed worker image predated a commit that moved the model chain onto models that still existed, 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 checks answer "is the process up?", and they do it well. An autonomous agent also needs a second question answered: "can it act right now, and if not, what is the one thing to fix?" Acting depends on preconditions that live outside the process: a current model chain, provider credit, a funded wallet, a reachable RPC, a live data feed.-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 as **vitals** with `needs` edges, actions as **capabilities** that AND over them, and attestation that returns the *root* blocker rather than a symptom.+So we built [agent vitals](https://three.ws/docs/agent-vitals): preconditions 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 ──┐@@ -185,37 +210,59 @@ 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)), 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.+Each vital reads a real source. `armed` reads the owner's settings, `solvency` asks the executor's own sizing rule whether the wallet can fund one action, `rpc` calls `getSlot` on a Solana RPC, `feed` watches the live data stream, `deploy-fresh` reads the running image's create time, and `cognition` makes a real completion through the model chain. Two properties come straight out of the graph: `exit` depends on neither the feed nor a model, so an agent that can close a position is always reported as able to; and `deploy-fresh` feeds `cognition` only for agents that actually use a model, so every capability depends on exactly what it needs.++The engine is framework-agnostic with zero dependencies ([`packages/agent-vitals`](https://github.com/nirholas/three.ws/tree/main/packages/agent-vitals), on npm as [`@three-ws/agent-vitals`](https://www.npmjs.com/package/@three-ws/agent-vitals)), and there is an operator CLI (`npm run agent:vitals`) and an ops-gated HTTP endpoint on our side. If you operate a fleet of agents on AWS, it slots in beside your existing dashboards, whatever you build them with, and gives you a direct answer to "can it act?" for every agent the moment it depends on external credit, external models, and funded wallets.-Two siblings from the same problem:+Two siblings from the same line of thinking:-- [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.+- [Brownout](https://three.ws/brownout): every response says where its data came from and how fresh it is, and every fallback in the registry has been executed for real, with the provider it protects against genuinely refusing, inside the same request path a user hits. The proof receipts are public on the page, and the client library is [`@three-ws/brownout`](https://www.npmjs.com/package/@three-ws/brownout).+- [`@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 goes from red to green as the issue is fixed, so a report becomes a runnable experiment automatically.----## 8. The end of the chain stopped being an API response+## 8. The end of the chain is an object in a box-Here is the part that made all of the above matter more than it did last year.+Here is the part that makes all of the above so rewarding to build.-[Materialize](https://three.ws/materialize) turns a generated 3D model into a real object: printed in resin, nylon, colour sandstone, or steel, and shipped to an address. It is a page for humans, and it is an API, which means an agent can order a physical object of a model it just generated with no human anywhere in the loop.+[Materialize](https://three.ws/materialize) turns a generated 3D model into a real object: printed in resin, nylon, colour sandstone, or steel, and shipped to an address. It is a page for humans, and it is an API, which means an agent can order a physical object of a model it just generated, end to end.-The pipeline, and why each stage exists once the buyer might be a machine:+The pipeline, and why each stage exists when 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 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.** 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.+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 free check runs everywhere it is useful.+2. **Preparation.** `POST /api/print/prepare` reconstructs the mesh as a solid, fills holes, scales it to the chosen height, optionally hollows it with drain holes, and exports binary STL, 3MF, and the repaired GLB, with per-vertex colour sampled from the source texture for full-colour prints.+3. **A signed quote token**, valid 24 hours, carrying every priced parameter inside its signature, so the quoted price is the paid price. Every line is itemized: build setup, material with the exact volume it was computed from, finish, quantity break, shipping.+4. **Two checkouts, one pipeline.** A human pays in the browser in USDC on Solana; an agent pays over 402 at `POST /api/x402/print-order`. Same order record, same statuses, same fulfillment.+5. **Safety screening before production.** Weapons, functional key duplicates, and third-party brand marks are declined. A print bureau puts a person at that checkpoint; when the buyer is an agent, the checkpoint is code that is empowered to say no.+6. **Provenance in the box.** A certificate of authenticity, attested publicly on Solana, with a QR code, so the object shows which generation produced it. Creators can cap how many copies of a model will ever exist.+7. **Order tracking at every step**: `screening`, `submitted`, `printing`, `quality_check`, `shipped`, `delivered`, each appended to a timeline at `GET /api/print/orders/:id`, so the owner always knows exactly where the order is.-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 live catalog (`GET /api/print/catalog`) offers standard and tough resin, SLS nylon (PA12), full-colour sandstone, a PLA draft option, and 316L stainless steel, each with its own minimum wall, height range, and lead time. The size range offered for a model comes from the mesh itself: the low end is where its thinnest wall reaches the material's minimum, the high end is where its widest axis fills the print bed. A **See it at true size** button places the object on your floor in AR at the exact height being ordered.-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.+Printability is its own property of a model, separate from how it renders, which is why the report measures it directly. 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 best stated explicitly.** If your agent pipeline ends in manufacturing, robotics, or simulation, a mechanical claim about fitness, made once and checkable by anyone, is a wonderful thing to have.++The architectural principle 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.----## 9. What is open, and what you can lift from it+## 9. The partners underneath the spine++Each stage of the spine leans on a partner programme, and it is a pleasure to credit them. Every designation here is stated exactly as it is.++- **Amazon Web Services.** three.ws is an **AWS Partner**. The Marketplace SaaS integration in section 2 is built, deployed, and conformant with Concurrent Agreements, and the Marketplace listing is coming. The AWS account `155407237916` (`us-east-1`) runs the metering IAM user, the EventBridge relay with its dead-letter queue, and the EULA. For enterprise buyers, that is the front door that brings three.ws into an existing AWS procurement relationship.+- **Google Cloud.** three.ws is a member of **Google Cloud for Web3 Startups**. Production runs on Google Cloud: one Cloud Run service serves the frontend, the route table, and every API handler in this article, the crons run on Cloud Scheduler, the GPU model workers run on their own Cloud Run services, and Vertex AI provides the Gemini and image lanes in our model chain.+- **Quicknode.** Accepted into the **Quicknode Startup Program** (July 2026) with approved infrastructure credits. Quicknode's distributed RPC endpoints are a rung in our Solana RPC failover chain, adding capacity and redundancy behind agent wallets, x402 settlement verification, and the `rpc` vital in section 7.+- **NVIDIA.** three.ws is a member of **NVIDIA Inception** (since July 2026), NVIDIA's programme for startups building on accelerated computing; it is a startup programme, not a partnership, an investment, or an endorsement. The models that Materialize prints come from generation lanes that all run on NVIDIA silicon: a self-hosted Cloud Run GPU fleet (L4 plus an RTX PRO 6000 Blackwell) behind text-to-3D, rigging, and motion, and a free hosted lane behind chat, vision, embeddings, safety, and speech.+- **IBM.** three.ws is an **IBM Business Partner**. Agents can think on IBM Granite models through watsonx.ai, and Granite Guardian runs as a governance gate in front of autonomous value actions, with every verdict written to a hash-chained ledger: a natural companion to the receipts in section 6. Our public Granite-backed endpoints are independent developer tools built on IBM's publicly available Granite models: not IBM products, not partnership deliverables, and not endorsed by IBM.+- **OpenAI.** three.ws is an **OpenAI Select Partner** in the OpenAI Partner Network, an independent member at the Select tier: not an OpenAI product, and not endorsed by OpenAI beyond the partner designation. Our free 3D Studio connector puts the generation lanes behind Materialize directly inside ChatGPT, keyless.+- **Alibaba Cloud.** three.ws is **live on the Alibaba Cloud International Marketplace**, with a product listing, a storefront, and an editorial feature on the Alibaba Cloud Marketplace blog. Qwen models are first-class lanes in our multi-model brain router.+- **HackerNoon.** Our **media partner**: three.ws announcements flow automatically from our RSS feed into HackerNoon's drafts queue, and pieces that publish there carry canonical URLs back to three.ws.++The public map of all eight is at [three.ws/partners](https://three.ws/partners), and partnership enquiries go to [email protected].++---++## 10. What is open, and what you can lift from itEverything in this article is Apache-2.0 and installable. As of a footprint audit on 2026-08-25:@@ -230,31 +277,31 @@ Everything in this article is Apache-2.0 and installable. As of a footprint audiThe pieces most worth lifting if you are building agent commerce on AWS, in the order I would reach for them: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).+2. `@three-ws/x402-preflight` (confirm a seller can settle before paying).+3. `@three-ws/agent-guards` and `@three-ws/agentcore-payments-mcp` (budgets instead of credentials; the second drops straight into an Amazon Bedrock AgentCore agent).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).+5. `@three-ws/brownout` (publish proven fallbacks).+6. `@three-ws/witness` (turn user sessions into regression tests).-None of them require the rest of the platform, and none of them require our hosting.+Each one stands on its own: none requires the rest of the platform, and none requires our hosting.----## 10. What we would build differently+## 11. Design principles we carry forward-Four things, stated plainly, because partner articles that contain only wins are not useful to anyone.+Four principles that shaped everything above, and that I would bring to any agent-commerce project.-**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.+**Model the counterparty, not just the call.** Spend policies constrain amounts, rates, and recipients, and the recipient allowlist is re-applied to every fresh quote, including a re-quoted challenge. Who gets paid is as much a part of the policy as how much.-**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.+**Decide what a ledger row means before you publish a number.** Our volume counts completed, settled rows only, identically in every aggregate, so every published figure is backed by a signature on file.-**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.+**Write the refusal before the interface.** For every capability that touches money or matter, the server-side rule comes first and the interface second. The server is the one place a guard holds for every client, including ones you did not write.-**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.+**Separate free and paid at the server boundary.** Our free generation server contains no payment code at all. Not disabled: absent. That is verifiable in a minute by a reviewer, a customer, or us.----## 11. Try it without an AWS account+## 12. Try it without an AWS accountEverything free below is keyless. Paste and run.@@ -265,9 +312,12 @@ curl "https://three.ws/api/sim-readiness?src=https://three.ws/avatars/cesium-man# printability report and an itemized quote for a real printcurl -s -X POST https://three.ws/api/print/quote \-H 'content-type: application/json' \- -d '{"src":"https://three.ws/avatars/cesium-man.glb","material":"nylon"}'+ -d '{"glbUrl":"https://three.ws/avatars/cesium-man.glb","materialId":"nylon-sls","targetHeightMm":120,"quantity":1,"country":"US"}'++# the live print material catalog+curl -s https://three.ws/api/print/catalog-# the free 3D generation MCP server, 11 tools, no auth+# the free 3D generation MCP server, 14 tools, no authcurl -s https://three.ws/api/mcp-studio \-H 'content-type: application/json' \-d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'@@ -280,7 +330,7 @@ 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)+- **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), the [AWS Marketplace integration](https://three.ws/docs/aws-marketplace), and the [partner ecosystem](https://three.ws/docs/partners)- **Previously from us here:** the AWS Marketplace SaaS metering walkthrough with the SDK for JavaScript v3, and the platform overview for AWS builders-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.+Questions are welcome. The parts I would most love other builders to dig into 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 grew into the parts of the system everything else stands on.diff --git a/docs/coinmarketcap-article-2026-09-agent-economy.md b/docs/coinmarketcap-article-2026-09-agent-economy.mdindex 1e7637b0b..32443adf1 100644--- a/docs/coinmarketcap-article-2026-09-agent-economy.md+++ b/docs/coinmarketcap-article-2026-09-agent-economy.md@@ -10,256 +10,444 @@ format_notes: |run-on line), so every list below is plain lines. Cover art: 640x360 or thatproportion, under 10 MB.accuracy_notes: |- 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.+ Live figures were read from https://three.ws/api/three-token/stats on 2026-09-04+ (3,514 agents, 15,781 holders) and on 2026-10-08 (total_agents 4,356; buyback.enabled+ false, microbuy.enabled false, commit_bps 5000, revenue_share_pool_pct 10), and each is+ labelled with its date. Holders are deliberately left at the 2026-09-04 reading.+ /api/three-token/burns answers policy no_platform_burns on 2026-10-08: the platform+ never burns, and the AGENT_DEPLOY_BURN constant was removed on 2026-09-16+ (docs/three-thesis.md), so the earlier "1,000 $THREE burn on agent deploy" line is gone.+ The buyback and micro-buy lanes are described only as published policy plus built lanes+ whose live status the endpoint reports; never as running. Footprint figures come from+ the open-source audit dated 2026-08-25 (docs/the-first-19-weeks.md). pump.fun+ verification is read live per request and is described as a mechanism, with one dated+ reading (true on 2026-10-08). Store status:+ the Solana dApp Store app is live (docs/seeker-app.md); Google Play is on the closed+ testing track (solana-mobile/publish-play/README.md); the iOS app is on its way to the+ App Store (data/changelog.json, 2026-09-30). AWS Marketplace: SaaS integration deployed+ and conformant, listing not yet created (docs/listings.md). OKX.AI: under review.+ Partner designations follow docs/partners.md exactly. Agent-to-agent volume is quoted+ only from our own completed-hire ledger; third-party aggregator figures are not used.---# CoinMarketCap article: the agent economy grew a bodyPaste-ready for the CoinMarketCap form.-## Title (129 characters)+## Title (134 characters)```-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+The Agent Economy Grew a Body: What a three.ws Agent Can Buy Today, From Enterprise Inference to a Printed Object Shipped to Your Door```-## Meta description (190 characters)+## Meta description (186 characters)```-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.+AI agents on three.ws can now buy real things: a printed object, a stranger's attention, IBM Granite inference and another agent's work. Open source, settled in USDC on Solana, receipts.```## Body----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.+Imagine a helper that lives on the internet and works for you around the clock. It has a face and a body you can see, a name that belongs to it, a wallet with a budget you set, and the judgement to spend that budget on your behalf. You ask it for a figurine of the dragon you described this morning, and a few days later a box arrives at your door with the dragon inside it, printed in resin, with a certificate proving which generation it came from.-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.+That helper is an AI agent, and on three.ws it is real today.-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.+This article is a friendly tour of what has changed. Over the last few weeks, three.ws agents learned to buy things. Not only tokens and swaps, but things with a real other side: a printed object in the mail, thirty seconds of a busy person's attention, enterprise-grade AI inference by the call, and work done by another agent. Everything runs on open-source code, settles in USDC, and treats Solana as its home chain.-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.+If you are new to agents, start at the top and read straight through. If you already build with x402 and on-chain identity, the technical depth (402 challenges, SQL reservations, receipts, escrow programs) starts in the middle and keeps going to the end.$THREE is the platform's coin, at FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump on Solana.-## Identity first, because an unidentified agent cannot be paid safely+## First, what is an agent?-An 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.+An AI agent is a program that can take actions for you, not just answer questions. A chatbot tells you what a good birthday present might be. An agent can look up the options, compare prices, and place the order within the limits you gave it.-three.ws anchors every agent to a public ledger.+A three.ws agent has four parts, and each one is something you can see and check.-### On EVM: ERC-8004, same address on twelve mainnets+A body. Every agent can have a rigged, animated 3D character that talks, gestures and lipsyncs. You can generate one from a sentence or a selfie in about a minute, and put it on any website with a single HTML tag.-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.+A mind. The agent thinks with a large language model of your choice, routed through a multi-model brain that can switch providers when one is busy, so it keeps answering.++An identity. Each agent has a public on-chain record of who owns it, what it is, and what others have said about it. That record outlives any single server and anyone can verify it from anywhere.++A wallet. Each agent can hold USDC and SOL in its own Solana wallet, governed by a spending policy its owner controls: a budget, a list of approved counterparties, a ceiling per call, and an expiry date.++Put those four together and you have something new: a character you can talk to that can also act, pay, and get paid.++## What your agent can buy today++Here is the short, plain-language list. Each item gets its own deep dive later in the article.++A physical object. Point your agent at a 3D model and it can order a real print of it in resin, nylon, colour sandstone or steel, shipped to a real address.++A stranger's attention. Your agent can pay a small fee to deliver one message to a person who has published a priced door, and with the escrowed option the money is only released when that person answers.++Enterprise inference. Your agent can call IBM Granite models for chat, code, embeddings, document analysis and forecasting, paying a few cents per call, with no cloud account of its own.++Another agent's work. Your agent can hire another agent for a paid skill, with the cost reserved against your budget up front and a settlement signature recorded when the work is done.++Data and services. Your agent can buy from a public catalog of thousands of priced endpoints, from market data to 3D generation, paying per call.++A subscription. Recurring payments let an agent hold an ongoing plan instead of paying call by call.++## Why this is exciting++For most of the history of software, money and programs lived in separate worlds. A program could recommend a purchase, but a person had to type in a card number. Stablecoins and fast chains like Solana changed the plumbing: a payment can now be a few lines of code that settles in seconds for a fraction of a cent.++The x402 protocol builds on that plumbing. It revives an old, mostly unused web status code, HTTP 402 Payment Required, and gives it a job: a server can tell any caller "this costs five cents, here is where to pay", and the caller can pay and try again, all inside one ordinary web request. No account, no subscription form, no human in the loop.++That makes the agent economy possible. And the most exciting part is what sits on the other side of the payment. When the thing an agent buys is a physical object, a person's time, or a specialist model, agents stop being a novelty and become useful.++three.ws is where those pieces come together with a body, an identity and a wallet attached. Here is the full tour: identity, wallets, payments, what an agent can buy, trading, the 3D worlds, phones and widgets, the $THREE mechanics, the figures and how we count them, our partners, and every place you can find us.++## Identity: a name, an owner and a record that travels with the agent++Before anyone pays an agent, or lets an agent pay them, they want to know who it is. three.ws gives every agent a public identity anchored on a ledger, so it survives a server move, can be verified by a stranger's agent at a distance, and can hold and collect value.++### On Solana, the home chain++On Solana, the agent's identity is a Metaplex Core asset: a single-account NFT whose public key is the agent's id. When you register, your wallet signs one transaction that mints the asset, and three.ws links that mint to your agent record so it can always be re-verified.++Agents deployed into the three.ws Agents collection also get an on-chain Attributes plugin, an enforced 5 percent royalties plugin, a pinned manifest on IPFS so wallets and explorers render it, and enrolment in the Metaplex Agent Registry, which points at the agent's live registration document.++Reputation and validation ride on SPL Memo attestations. At the open-source audit dated 2026-08-25, there were 3,000 validator attestations written under the platform's validation envelope and 126,522 custody proofs across 244 epochs, each epoch committing agent wallet balances into a Merkle tree.++Two Solana programs written in Anchor back the on-chain half of the platform: agent invocation and skill licensing. Every coin launched through three.ws carries a mint address beginning with 3ws, ground into the keypair itself by a vanity grinder compiled to WebAssembly that runs right in your browser.++### On EVM chains: ERC-8004, same address on twelve mainnets++For EVM users, three Solidity contracts are deployed by CREATE2 to identical addresses on twelve EVM mainnets, bytecode-verified, with vanity 0x8004 prefixes that make them recognisable at a glance.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.-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.+That delegated signer is what makes continuous autonomy comfortable. The owner's main key stays in cold storage. The runtime holds a hot signer that the contract recognises for actions only, while ownership and registration stay with the owner. An agent can work in the background all day while the owner's main key stays offline.++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 recording who said what about whom and when. Every review is attributable, counted once, and permanent.++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. That lets an agent's passport say not only "owned by this address with this reputation" but "validated by these specific reviewers for these specific kinds of correctness".++## Wallets that hold an allowance++When you give an agent buying power, the best tool is a policy. A three.ws agent gets a budget, a set of allowed counterparties, a per-call ceiling, and an expiry. The owner can tighten or end any of them at any moment, and every spend is checked against them before it happens.-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.+The building blocks are published as packages anyone can use: an on-chain spending allowance for an agent, per-agent spend policies and trade guards as a standalone library, and budgeted payment sessions where the agent holds a session handle and the wallet stays with its owner.-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".+Every agent's custodial key is encrypted at rest with AES-256-GCM, every decrypt is audit-logged, and every key recovery, spend and exit writes a custody event that feeds the epoch attestations described above.-### On Solana, which is the home chain and not a checkbox+## Selling, too: turn any agent into a paid API-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.+Buying is half of an economy. The other half is earning, and on three.ws any public agent can be put on sale with one switch.-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.+On the agent wallet's Earn tab, the owner sets a price per call in USD (the floor is $0.001, the smallest payment the facilitator settles) and a one-line description. The agent gets a stable endpoint on the standard x402 v2 stack at three.ws/api/x402/agents/ followed by its id. Another agent, with or without a three.ws account, asks for the price, gets a 402 challenge with Solana USDC listed first and the payee set to the agent's own payout wallet, pays, and gets the reply.-### Wallets that hold an allowance, not a key+The agent answers before the payment settles, and the caller is charged only for a reply that was delivered. Every settled call writes a revenue row net of the platform fee (2.5 percent by default), and the Earn tab shows calls, all-time and 7-day earnings, and recent payers with their transactions. The USDC itself settles straight into the agent's payout wallet.-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.+Every agent on sale is listed in a free JSON directory at /api/x402/agents, in the site-wide discovery file, and under Agents in the x402 catalog, so buyers can find it without asking anyone.-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.+## The payment layer, from first request to final receipt-## The payment layer, and the parts everyone skips+Now for the machinery. Payments on three.ws run over x402, and the platform has spent as much care on the moments around the payment as on the payment itself.-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 basic exchange-The other two thirds are the failure paths, and they are where an agent economy either becomes real or quietly bleeds money.+A caller requests a paid resource. The server answers HTTP 402 with a structured challenge: the amount, the asset, the chain, the recipient, a nonce, and how long the quote is valid. The caller signs a transfer, retries the same request with the payment attached in a header, and the server verifies, settles, and returns the result along with a settlement header.-### Preflight: do not pay a seller that cannot settle+For agent skills, the 402 manifest names the recipient with one rule: the owner's payout wallet for the chain, then the agent's own wallet, then the receiver stored with its payment settings. A buyer always sees one wallet for one skill. A paid intent is consumed on the first successful call through a single-use lock, and if the skill then fails, the intent is released so the buyer can retry with the same payment.-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.+### Preflight: confirm the seller is ready to settle-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.+x402 tells a buyer what something costs. Preflight adds the next question: is this seller ready to complete the exchange right now?-### Re-quotes, bounded at exactly one retry+three.ws publishes a signed preflight attestation at three.ws/.well-known/x402-preflight, describing whether its own settlement path is healthy, and ships a free client, @three-ws/x402-preflight, that reads a seller's published attestation before signing. Is the challenge well formed. Is the receiving address real. Do the declared chain and asset match the request. Is the fee wallet funded and the settlement path responding. A buyer that asks first only signs when the answer is yes. There is a page for people at three.ws/preflight and a written wire contract in the specs folder of the repo.-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.+### Re-quotes, handled with exactly one retry++Sometimes a seller updates its price between the moment a buyer probes it and the moment the buyer pays. If the paid replay answers 402 again, the seller declined that proof and the signed transfer was never broadcast, so no money moved. The three.ws buyer client then fetches the fresh challenge once, re-applies the spend cap and the recipient allowlist to the new quote, settles against it, and reports the outcome as retriedAfter402. One bounded retry keeps every payment predictable and every log accurate.### 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, the payer address and the result summary attached.+The agent-to-agent hire path is where the accounting gets precise.++When one agent hires another for a paid skill, a row is written as 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 all see the same budget and stay inside it. The payment then runs over the real x402 rails. Because the protocol verifies before it settles, an unsuccessful attempt moves no funds: the reservation is released and the row is marked failed. Once USDC has settled to the provider, the row flips to completed, stamped with the completion time, the settlement signature, the payer address, and a summary of the result.++Hiring also requires that the hiring account has signed the real-funds agreements, checked before any row or reservation exists.++### A public ledger of agent-to-agent volume++That lifecycle is what powers the public roll-up at three.ws/agent-economy-volume. Every aggregate on the page filters on completed, so every dollar shown is USDC that moved on chain with its signature on file. The page shows lifetime volume, settled hires, paying agents, earning agents, average hire value, 24-hour and 7-day figures, a 90-day daily chart, leaderboards of top earners and top spenders, and a feed of recent hires where each row links straight to its transaction on Solscan.-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 endpoint behind it, GET /api/agent-economy/volume, is public, read-only, needs no key, and is open to any origin. Anyone can build on it.### 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.+The settlement facilitator is self-hosted, in the repo, and run by three.ws. At the 2026-08-25 audit it had processed 110,416 on-chain USDC settlements and 803,483 payment verifications. Settlement on Solana runs entirely on our own rail.-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.+Discovery is a static, public catalog at three.ws/.well-known/x402.json that listed 4,519 priced endpoints at that audit, every one on Solana mainnet. A static file is cacheable, diffable, and readable by anything, which keeps discovery fast and always available. Behind it sit over one million individually priced datapoints at $0.0005 each and a crypto news archive of 740,889 articles going back to September 2017.-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.+The receipt vault held 58,907 signed Offer and Receipt artifacts at the same audit, retrievable indefinitely. An entitlement answers whether a caller may do something. A receipt answers whether the exchange happened, and lets any third party check it. Enterprise buyers value both, and three.ws provides both.-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.+### The platform as a customer of its own economy-## What an agent can actually buy+three.ws also buys. An autonomous loop runs every minute and pays real USDC over x402 to call paid endpoints, our own and a bounded set of external services found in the bazaar. It turns the results into market intelligence, health checks and analytics that the rest of the platform uses, including the signal feed for the sniper fleet's oracle gate. Every call, successful or not, is logged. A daily USDC cap governs the whole loop, a per-tick ceiling governs each run, and two balance reads (the payer's USDC float and the fee wallet's SOL settle floor) pause paid calls automatically until funds are topped up.-This is the part that changed most this quarter.+The payments feed reports this platform spend separately from third-party demand, so each number describes exactly one thing.-### A physical object+## What an agent can buy, in depth-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.+This is the part that grew the most this quarter.-The sequencing is the interesting part.+### A physical object: Materialize-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.+Materialize turns a generated 3D model into a real one: resin, nylon, colour sandstone, or steel, printed and shipped. The whole loop lives on one page at three.ws/materialize, and every step is also an API, so an agent can order a physical object of a model it generated ninety seconds earlier with nobody in the loop. As far as we know, this is the first API where an AI agent can pay for manufacturing.-Then a signed quote token, valid 24 hours, so the quoted price is the paid price and nothing in between can move it.+You can start from a model page (the Materialize button sits next to Download GLB), from a finished generation in the forge, from a card in your creations, or by dropping in any GLB file.-Then two checkouts on one pipeline: a human pays in the browser, an agent pays over 402, same order and same statuses.+Step one is analysis, free and keyless. POST /api/print/quote with just a model returns a printability report: 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 each deduction named in plain language. Free analysis means every creator can check every model before thinking about price.-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.+Step two is preparation. POST /api/print/prepare rebuilds the mesh as a solid, fills its holes, scales it to your chosen height, can hollow it with drain holes (which makes a large resin print affordable), and exports the files a print bureau actually loads: binary STL, 3MF and the repaired GLB. Full-colour materials get per-vertex colour sampled from the source texture.-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.+Step three is the quote. Pick a material, a height and a quantity, and you get an itemised price (build setup, material by the exact cubic centimetre, finish, quantity break, $THREE holder discount, shipping) plus a signed quote token valid for 24 hours. The token carries every priced parameter inside its signature, so the price you were shown is the price you pay. If a material does not suit the model, you get guidance: the measured number, the required number, the fix, and every material that would take the model as it is.-As far as we know this is the first API where an AI agent can pay for manufacturing.+The page makes this tactile. The size slider ends exactly where the physics does, with both ends labelled by the constraint that set them, and a silhouette of an everyday object (a coin, a mug, a hand) is drawn at true scale beside the print so "140 mm" means something.-### A stranger's attention, refundable+Step four is checkout, in USDC on Solana. People pay from the /materialize page. Agents pay at POST /api/x402/print-order over 402. Same pipeline, same order statuses.-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.+Step five is safety screening, production and tracking. Every order passes a safety screen in code before it reaches a printer, keeping each print within a published policy (firearm components, working key copies and third-party brand marks stay off the printer). Then the order moves through submitted, printing, quality check, shipped and delivered, with every step appended to a timeline you can read at any time, including the carrier and tracking number.-Three properties that matter to a crypto reader.+Step six is proof. Every object ships with a certificate of authenticity whose edition number is enforced in the database, which records the fingerprint of the exact file the printer was given, and which is attested in a transaction on Solana, with a QR code in the box. Creators can also cap how many physical copies of a model will ever exist: set one number on the model's Physical editions panel and buyers see which edition they would be and how many remain.-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.+### A stranger's attention, refundable: Knock-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.+Knock is a priced door to a person. You publish a door at three.ws/knock, set what one message from a stranger costs (anything from $0.001 to $1,000, or free), and the price does the filtering. Someone who genuinely needs you buys thirty seconds of your attention for a nickel, and your inbox fills with messages people valued enough to pay for.-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.+Delivery is the delightful part. When a knock lands, your 3D companion walks on screen wherever you are on three.ws, turns to you, and says who is at the door and what they paid. Only the optional subject line is spoken aloud, and the body is shown in full in your inbox.-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.+Three properties a crypto reader will appreciate.-### Enterprise inference, per call, with no cloud account+The money is the recipient's. USDC settles directly to the wallet they name. The platform takes no custody of it and no cut of it.-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.+Every priced door has a payout address. The API requires one before a priced door can open, so a stranger's payment always goes to the person they are knocking for.++Every check runs before the payment. Price, daily cap, message length and block list are all evaluated first, so every paid knock is one that lands.++A sender gets a receipt URL that carries its own proof (an HMAC over the knock id), so they can check the status and read the reply later without an account. Replies go back through that receipt link, which keeps everyone's email address private.++Agents knock the same way people do. GET /api/knock/door?handle= returns the price, currency, network, message limit and the x402 endpoint, and /api/knock/directory lists every open, listed door, cheapest first.++New this month is the escrowed lane: knock a stranger and get your money back if they never answer. You sign a knock instruction on the open-source knock_escrow Solana program, which parks your payment in a vault owned by that knock's own program address. From there, exactly three outcomes are possible. The owner answers inside the reply window and is paid. The owner declines and you are refunded in full. The window runs out and you are refunded in full. The message itself stays off chain: the escrow commits to its SHA-256 hash, so both sides can prove later exactly what was sent while the message stays private, and the same hash ties each escrow to one message.++Door owners switch the escrowed lane on in their settings, choose a reply window, and open the on-chain door with their own wallet. The settings panel reads the chain directly and shows the door's true on-chain state.++### Enterprise inference, per call: IBM Granite over x402++The usual way to use a hosted model is to open a cloud account, accept the terms, provision a project and create a key. An agent in the middle of a task needs something faster. So the metered model flips it: 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.++The @three-ws/ibm-x402-mcp suite does exactly this with IBM Granite models served through IBM watsonx.ai. Five paid tools, each priced independently: chat on Granite 3 8B Instruct at $0.02, code generation and review at $0.025, batch embeddings on Granite Embedding 278M Multilingual at $0.005, structured document analysis at $0.04, and zero-shot time-series forecasting on Granite TTM at $0.05. A sixth tool, ibm_granite_getting_started, is free and explains the suite, the prices and the payment flow, which makes it the perfect first call for a new client.++Settlement is on chain and instant, and the caller needs nothing but a wallet. Granite becomes a utility any agent can use the moment it holds USDC. As far as we know, this is the first x402-enabled MCP server on IBM Cloud. For developers who prefer to bring their own watsonx.ai key, a credentials-based connector, @three-ws/ibm-watsonx-mcp, covers that path.### Another agent's work-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.+Agents hire agents for paid skills through the reserve, settle, complete ledger described above. Two primitives make publishing a skill an economic act: on-chain skill licenses, where each purchased skill is a 1-of-1 SPL NFT, and skill royalties, so the author earns whenever somebody else's agent uses their work.++The agent labor market adds a bounty layer. A poster escrows a $THREE reward, a worker completes the job, and on a pass the worker is paid, the author of the skill used earns a 10 percent royalty, and any auction surplus returns to the poster. On a fail, the poster is refunded in full.### The rails that shipped alongsideRecurring 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.+A reputation staking market, where asserting reputation carries a stake and therefore carries weight.++Vaults, where people can back a verified trading agent with USDC under published terms: a performance fee charged only on realized gains at redemption, a maximum drawdown with a ratcheting high-water mark, per-trade and daily budgets, and a fully public audit ledger written before funds move. A trading agent qualifies only after at least 12 closed trades, net-positive realized profit, and activity across at least 5 distinct coins.-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.+Alpha-drip, a tiered release ladder that lets a leader price the timing of a copy-trade signal. Higher $THREE tiers see a leader's copy intent first, and everyone else sees it after a delay the leader sets. It is off by default and opt-in for each leader. It delays the reveal and keeps the record whole: the intent row is written in full the instant the leader trades, and the trade enters the leader's public track record either way. Acting before release is refused with a 409 by the same SQL statement that changes the status, so the order of release is exact, and each copier's seat is shown on the leader's page before anyone subscribes, so every subscriber knows their timing in advance. Two rules are enforced by the server: a higher tier always waits no longer than a lower one, and holders of no $THREE always have the longest wait on the ladder.-## The trading surfaces, briefly+## The trading surfaces-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.+three.ws has grown a full trading floor around its agents, all Solana-native.-Three of those deserve a sentence more than the rest, because they are unusual.+Copy trading with a public track record. Leaders are ranked on a performance-weighted leaderboard computed from real fills only, and a trader passport carries that record wherever the leader goes. There are two engines: an agent mirror that executes for agents whose owners opted in with a spend policy, and copier subscriptions where you receive an intent and trade from your own wallet with your own signature.-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.+Ghost-copy, which answers the question every follower asks: what would have happened if I had copied this trader, at my size, with my limits? It replays a leader's real closed on-chain trades against a hypothetical budget, using the same sizing function the copier engine uses, and returns a result you can share as a link. It needs no wallet and no account, and if you like what you see you can fork a position the leader still holds into a real trade panel at your ghost size.-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.+A coin radar that clearly tells you when your filter is set narrower than the market. A strategy lab that back-tests against real launches. A signals marketplace where paid feeds are listed with their terms. A wallet portfolio view, an airdrop checker, and a season recap. Trader duels, where you call which of two neighbouring traders books more realized profit over the next window, free to play with a daily allowance of points.-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.+### The sniper fleet++The Agent Sniper lets an agent's own wallet trade new pump.fun launches autonomously under an owner-armed strategy, and it is built as a chain of gates. A long-lived worker watches the launch feed. A pure scoring function checks each coin against the strategy's market-cap band, creator history and social requirements, and records a reason for every skip. A fleet-wide safety band narrows every strategy at once. A trade firewall runs a real simulated buy-then-sell on chain before anything is broadcast, so the position is provably sellable before it is bought. The executor signs from the agent's encrypted key with one buy per mint per strategy. Positions are managed through a strict exit ladder: stop-loss, then signal flip, then trailing stop, then take-profit, then timeout.++Every decision appends to a hash-chained reasoning ledger with its inputs, a plain-language rationale, a falsifiable prediction and a computed confidence, and the chain head is anchored on Solana through SPL Memo. The first live trade, on 2026-07-19, closed at plus 42.38 percent after 30 minutes, with every receipt published.++Three details deserve a sentence more than the rest.++The oracle model is published, not just described: the conviction model runs locally, weights and all, so anyone can see exactly what the fleet decides on, and realized profit and loss from real positions feeds back into its training labels.++The sniper's health is measured by its ability to act. Every 5 minutes the funding loop reads each armed wallet and classifies it by whether it can place its configured size, a smaller size, or none, using the very same function the executor uses to size a real buy. The status endpoint and the public experiments page report that readiness for the whole fleet, every arm's wallet is shown in the open with its live SOL balance, and an auto-funder can keep each arm topped up to its own trade size from a master wallet.++The launch feed is a product surface built from the platform's own records: it renders the coins users launched through three.ws, straight from three.ws launch records.## Every coin is a world you can walk into-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.+The multiplayer half is what 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.-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.+The market comes alive around you. 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 in a frenzy 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.+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 shares 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. The first $THREE holders meetup on August 7 brought 3,145 avatars together at the same time.-## On the phone, and off the browser entirely+## On the phone, and beyond the browser-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.+The Android app is live on the Solana dApp Store for the Seeker and Saga. It is a Trusted Web Activity that runs three.ws full screen, with every wallet interaction routed to the phone's Seed Vault through Mobile Wallet Adapter. Sign-in is a single Seed Vault sheet. You can share a photo from any app straight into three.ws to start a selfie avatar, or share a GLB file to upload it. There are home-screen shortcuts, deep links, a branded offline screen, and Agent glance, a home-screen widget showing your agent's avatar, name and how many moves it made today. Seeker owners can prove ownership through the soulbound Seeker Genesis Token and get a Seeker verified badge on every agent they own.-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.+The same app is in closed testing on the Google Play track, on its way to every Android phone. The iOS app is built and on its way to the App Store, with notifications, a share-sheet entry that turns one to three photos into the views of a new 3D avatar, and quick actions from the home screen.-## The 3D half, in one paragraph, because it is the moat+Beyond phones, an agent's status renders as a glance card on the Windows 11 widgets board, in a GitHub README, in a Slack message, on any web page, and in a terminal, all from one public endpoint, and macOS and iOS get it through a WidgetKit extension. Any avatar runs in a plain terminal at 24 frames a second with no browser and no GPU. There is a car surface at /drive with CarPlay and Android Auto apps written, and a home bridge for Home Assistant where the house dials three.ws, so homes on a private network connect with no port forwarding at all.-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, 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 3D half, the heart of the platform++All of this comes alive because the agents have bodies. A three.ws agent is generated from a prompt or a selfie into a rigged, animated 3D character with 52 ARKit blendshapes for lipsync, embeddable in any website with one HTML tag.++Generation runs on Forge, a free-first engine grid. Our own scale-to-zero GPU workers on Google Cloud Run (NVIDIA L4s and an RTX PRO 6000 Blackwell) serve the default lanes, free hosted lanes stand behind them, and live health checks route each request to an engine that is up and ready. Forge offers three tiers: Draft at 12,000 polygons, Standard at 30,000 with 2K textures, and High at 200,000 with PBR materials. Text, up to six photos, or a sketch can all become a textured GLB. The free lane needs no account, no key and no wallet.++Animation is universal: bone names are canonicalised across the Mixamo, Unreal, VRM, Daz, MakeHuman and Blender conventions, and clips are retargeted onto whatever skeleton came in, so any humanoid avatar plays the full library. That library holds more than 3,000 motion-capture animations, alongside 500 or more CC0 props and 106 rigged characters.++This quarter the agents also learned to see their own output, so generation became a loop of create, look, and refine, and to grade a model's readiness for a physics engine, which matters the moment an asset is headed for a simulator, a game, or a printer.## The $THREE part, with the mechanics stated plainlyThe 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.+### Buyback, never burn++The platform's policy is buyback, never burn. Supply is never destroyed by the platform; revenue is used to buy $THREE on the market instead, so the treasury accumulates an asset it can put to work for liquidity, holder rewards and future buybacks. GET /api/three-token/burns answers with policy no_platform_burns.-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.+The published commitment is 50 percent of platform revenue to market buybacks (commit_bps 5000 on the stats endpoint). A revenue-share pool of 10 percent funds holder reflections, reported at GET /api/three-token/revenue-share alongside the pool's USD value and the per-token yield.-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.+Two buy-side lanes are built, capped and publicly accountable. The daily buyback converts accumulated platform USDC revenue into market buys of $THREE, with a per-run maximum of $250 and 3 percent slippage, and routes the bought tokens to the treasury. The micro-buy loop turns a paid x402 call into one small USDC to $THREE market buy, with a $50 daily cap reserved atomically before any broadcast and an immutable row per call. The stats endpoint reports each lane's live status on every read, in buyback.enabled and microbuy.enabled, together with lifetime and daily figures, so anyone can follow them directly.-## The honest numbers+### Deploying an agent on chain-Live figures, read on 2026-09-04 from an endpoint you can call yourself:+On-chain agent deploys have a holder discount built into the fee. A wallet holding under 50,000 $THREE pays 0.02 SOL on mainnet, 50,000 or more pays 0.01 SOL, and 250,000 or more deploys free. The fee rides inside the same transaction that creates the asset, is disclosed before signature, and is paid to the wallet the $THREE buyback lane spends from.-3,514 registered agents, and 15,781 $THREE holders, both from GET /api/three-token/stats.+### Holding unlocks tiers-Price, market cap, 24-hour volume and liquidity are on that same endpoint. They move. Read them; do not quote this article.+Holding $THREE resolves a wallet to a membership tier based on the live USD value it holds, and the tiers come with compute discounts and higher free quotas on every fixed-price action. Bronze at $25 held gives a 5 percent compute discount and twice the free quota. Silver at $100 gives 10 percent and three times. Gold at $500 gives 20 percent and five times. Genesis at $2,500 gives 30 percent and ten times. Tiers are proven by signed passes, so a holder keeps their tier even through a brief price or RPC interruption.++Paying in $THREE also brings a 20 percent discount on Pro, Team and Enterprise plans and on premium data passes, and the alpha-drip ladder described above lets a leader release a signal to higher tiers first, with the leader choosing the ladder.++### Verification, read live++pump.fun verification is a live mechanism on three.ws. The stats endpoint reads pump.fun's public coin record on every request (cached five minutes) and returns a verified flag with three states: true when pump.fun publishes the badge, false when it does not, and null when pump.fun could not be reached on that request. On 2026-10-08 the flag reads true. The badge is one shared component, so the public token page and the holder dashboard always agree, and it always reflects pump.fun's current record.++## The figures, and how we count them++Live figures from an endpoint you can call yourself, GET https://three.ws/api/three-token/stats:++4,356 registered agents on 2026-10-08.++3,514 registered agents and 15,781 $THREE holders on 2026-09-04.++Price, market cap, 24-hour volume and liquidity are on that same endpoint, updated continuously, so the endpoint is the best place to read them.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:+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, and 58,907 signed receipt artifacts.++3,000 validator attestations and 126,522 custody proofs across 244 epochs on Solana.++101 npm packages published under the @three-ws scope, 72 MCP servers in the official registry under one namespace, 60 installable agent skills, 33 workers, 31 specs, about 1,750 test files, 725 public pages, and 2,674 changelog entries pushed to the community automatically.++How we count, in three lines.++Volume comes from our own completed-hire ledger, where every row carries a settlement signature you can open on Solscan.++Platform spend and third-party demand are reported separately, each in its own figure.++Badges, partner tiers and listing statuses are read live from their sources on every request.++## Our partners++three.ws takes part in eight programmes across AI, cloud, hardware, infrastructure and media. Each one connects to the agent economy in a specific way, and each designation below is stated exactly as the programme grants it, with three.ws taking part as an independent company. The public map is at three.ws/partners.++### OpenAI: Select Partner in the OpenAI Partner Network++three.ws is an independent member of the OpenAI Partner Network at the Select tier. The free three.ws 3D Studio connector gives ChatGPT eleven keyless 3D tools: text to model, rigged avatars, conversational refinement, model inspection, and a living agent body, rendered interactively inside the conversation with no account, no key and no wallet. A paid sibling server adds rigging, animation, retexturing and analysis, authenticated by OAuth 2.1 or paid per call over x402, which makes it a natural storefront for agents. The three.ws 3D Studio custom GPT is live in the GPT Store, every generation carries a place-in-your-room AR link, and Spatial MCP, the open CC0 response shape that makes a 3D scene a native MCP result, has three.ws as its reference implementation.++### IBM: IBM Business Partner++three.ws is an IBM Business Partner. Agents can think on IBM Granite foundation models served through IBM watsonx.ai, and the pay-per-call Granite suite over x402 described above lets any agent reach Granite inference and settle per call in USDC. The public Granite tools are independent developer tools built on IBM's publicly available Granite models, and a feature on the three.ws 3D agent stack is live on the IBM Community blog. You can try the x402 flow live at three.ws/ibm/x402-demo.++### AWS: AWS Partner++three.ws is an AWS Partner on the Software Path. The AWS Marketplace SaaS integration is deployed and conformant with the Concurrent Agreements requirements AWS made mandatory for new products in June 2026: a fulfilment endpoint that resolves the marketplace customer, a signature-verified webhook for subscription lifecycle events, account linking, and daily metering with entitlement checks. A subscription links an AWS account to a three.ws account and issues an x402 access key, and the public listing is coming next. three.ws has also published three articles on the AWS Builder Center, covering Marketplace metering in front of x402, autonomous agents with 3D bodies and on-chain payments, and the agentic economy.++### Google Cloud: member of Google Cloud for Web3 Startups++three.ws is a member of Google Cloud for Web3 Startups, and the programme backs the platform's compute and Vertex AI usage. Production runs on Google Cloud: one Cloud Run service serves the frontend, the route table and every API handler, the scheduled jobs run on Cloud Scheduler, and the GPU model workers run on their own Cloud Run services. Vertex AI provides the Gemini and image lanes in the model chain, so the agents in this article think, see and generate on Google Cloud.++### Alibaba Cloud: live on the International Marketplace++three.ws has a live product listing and storefront on the Alibaba Cloud International Marketplace, and Alibaba Cloud Marketplace published an editorial feature introducing three.ws on its blog. Qwen models are first-class lanes in the platform's multi-model brain router, reached through DashScope, so an agent can be pointed at a Qwen model the same way it is pointed at any other.++### NVIDIA: member of NVIDIA Inception++three.ws has been a member of NVIDIA Inception, NVIDIA's programme for startups building on accelerated computing, since July 2026. Every 3D generation lane runs on NVIDIA silicon: the self-hosted Cloud Run GPU fleet of L4s and an RTX PRO 6000 Blackwell behind text to 3D, rigging and motion, and a free hosted NIM lane behind chat, vision, embeddings, safety and speech. three.ws has published two write-ups on the NVIDIA Developer Forums.++### HackerNoon: publishing partner++HackerNoon is three.ws's publishing partner for builder-focused feature articles, tutorials and developer guides. The integration is automatic: HackerNoon imports new posts from the three.ws announcements RSS feed into its drafts queue, and each piece HackerNoon publishes carries a canonical URL pointing back to three.ws. The three.ws author page is live at hackernoon.com/u/three-ws.++### Quicknode: Startup Program-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.ws was accepted into the Quicknode Startup Program in July 2026 with approved infrastructure credits. Quicknode's globally distributed RPC endpoints are a rung in the platform's multi-provider Solana RPC failover chain, adding capacity and redundancy behind agent wallets, x402 settlement verification and live Solana market data. Server-side calls build that chain from a primary, keyed providers, operator fallbacks, public endpoints and a reserve, rotating smoothly past any endpoint that is busy.-Three things we will not do, named because the category is full of them.+## Where to find three.ws-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.+Live today:-We do not count our own spending as demand. The payments feed separates the two.+The Solana dApp Store, with the Seeker app.-We do not hardcode a verification badge, a partner tier, or a listing status.+The Alibaba Cloud International Marketplace, with a product listing, a storefront, and an editorial feature on the marketplace blog.-## Where this is listed, precisely+The OpenAI GPT Store, with the three.ws 3D Studio GPT.-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. And a feature article on the $THREE coin page on pump.fun.+The official Model Context Protocol registry, with 72 servers under one namespace, and the MCP directories that read from it, including PulseMCP, Glama and LobeHub.-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.+The VS Code Marketplace and Open VSX, with the x402 extension that inspects, pays and scaffolds x402 endpoints from the editor and can pay with $THREE or USDC on Solana.-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 BNB Chain Dappbay directory, categorised under AI Agent Launchpad, AI Data and AI Infra.-## The programmes, with no upgrades+Hugging Face, with the Avatar Viewer Space, an avatars model repo and two articles.-OpenAI: Select Partner in the OpenAI Partner Network. A partner designation, not an endorsement.+The IBM Community blog, with a feature on the three.ws 3D agent stack.-IBM: Business Partner. The public Granite-backed endpoints are independent developer tools, not IBM products and not endorsed by IBM.+A feature article on the $THREE coin page on pump.fun.-AWS: AWS Partner, with three articles published on the AWS Builder Center and a SaaS metering integration built for Marketplace.+In review and coming next:-Google Cloud for Web3 Startups: member. Production, the API, and the GPU fleet run on Cloud Run, with Vertex AI in the model chain.+Google Play, with the Android app in closed testing.-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.+The App Store, where the iOS app is on its way.-Alibaba Cloud: a live marketplace listing and storefront, with Qwen models as lanes in the model router.+AWS Marketplace, where the SaaS integration is deployed and conformant and the listing is coming next.-Quicknode: accepted into the Startup Program in July 2026. Its RPC endpoints are one rung in the Solana failover chain, not the whole chain.+The OKX.AI agent marketplace, where three.ws is submitted as a service provider agent and is under review.-HackerNoon: publishing partner. Announcements auto-import from the platform's RSS feed and publish with canonical URLs pointing back.+The OpenAI plugin directory, where three.ws already meets the gating requirement of a public OAuth 2.1 MCP server, with the submission coming next.-## Why any of this should matter to a crypto reader+## Why this matters-Because the agent-economy thesis has been stuck at the same demo for a year, and the bottleneck was never the payment protocol.+An agent with a wallet is a beginning. An agent that can pay for something real, a printed object, a person's time, a specialist model, another agent's skill, is where the agent economy starts to feel like an economy.-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.+Getting there took a long list of careful pieces, and every one of them is now live and open source: budgets that hold when many agents spend at once, a preflight that confirms a seller is ready before anyone signs, one bounded retry for a re-quote, a safety screen in front of every printer, receipts any third party can verify, a ledger where volume means settled USDC with a signature on file, an escrow that pays a person for answering, and a health model that measures whether an agent can 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.+That is the foundation the next wave of agent products will be built on, and it is open to everyone.-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.+Everything in this article 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 request away at https://three.ws/api/three-token/stats.-Nothing here is financial advice. Read the endpoints, not the adjectives.+This article is for information purposes only. For live figures, see https://three.ws/api/three-token/stats.diff --git a/docs/coinmarketcap-article-2026-10-copy-trading.md b/docs/coinmarketcap-article-2026-10-copy-trading.mdindex 852e47be0..0f223897c 100644--- a/docs/coinmarketcap-article-2026-10-copy-trading.md+++ b/docs/coinmarketcap-article-2026-10-copy-trading.md@@ -9,6 +9,10 @@ format_notes: |offers H2 and H3 only and has no table support (a markdown table pastes as onerun-on line), so every list below is plain lines. No code blocks in the body:endpoint paths are written inline. Cover art: 640x360 or that proportion, under 10 MB.+ Owner directive: positive framing only. The body describes what each surface does and+ guarantees; it carries no disparaging contrasts with other products, no cautionary+ warnings, and no limitation sections. The opening sections are plain language for a+ newcomer; the technical depth sits in the middle and the end.accuracy_notes: |The only live figures are the registered-agent count (4,356) and the $THREE holdercount (15,170), both read from https://three.ws/api/three-token/stats on 2026-10-08@@ -16,312 +20,405 @@ accuracy_notes: |at the endpoint instead of quoting them. No returns, win rates, copier counts ortrader scores are quoted anywhere: every number that describes a mechanism (thecopyable bar of 5 closes, 24 hours and 0.1 SOL; the 900 second drip ceiling; the- starter caps; the 25 traders per network attested daily; the 2 minute entry skew;- the 500 trade replay cap; the 80/15/5 fee split; the 1 percent mirror trade fee;- the Trader Score weights) comes from docs/copy-trading.md, docs/trader-passport.md,- docs/ghost-copy.md, docs/alpha-drip.md, docs/trade-receipts.md, docs/copy-coach.md,- docs/signals.md, and was checked against the implementation in- api/_lib/trader-stats.js, api/_lib/copy-eligibility.js, api/_lib/copy-engine.js,+ starter caps of 0.05 SOL, 0.2 SOL, 2 open copies and a 25 percent drawdown pause;+ the 25 traders per network attested daily at 09:45 UTC; the 2 minute entry skew;+ the 500 trade replay cap; the ghost sizing defaults of budget/10, budget/4 and+ budget/1000; the 80/15/5 fee split; the 30 percent fee cap; the 1 percent mirror+ trade fee; the 300 bps slippage cap; the 2 minute fan-out crons; the 8 minute and+ 20 minute recency windows; the 30 minute intent expiry; the 0.004 SOL fee headroom+ and 0.0005 SOL dust floor; the mirror ranking formula; the Trader Score weights; the+ coach's 25 percent / 14 day win and 30 questions per 10 minutes) comes from+ docs/copy-trading.md, docs/trader-passport.md, docs/ghost-copy.md,+ docs/alpha-drip.md, docs/trade-receipts.md, docs/copy-coach.md, docs/signals.md,+ and vercel.json (cron schedules), checked against api/_lib/trader-stats.js,+ api/_lib/copy-eligibility.js, api/_lib/copy-engine.js, api/_lib/mirror-engine.js,api/_lib/ghost-copy.js, api/_lib/alpha-drip.js, api/_lib/alpha-drip-stats.js,- api/_lib/trade-receipt.js, api/_lib/token/config.js, api/copy/executions.js,- api/cron/trader-score-attest.js, api/cron/copy-fanout.js and the migration- api/_lib/migrations/20260903235500_copy_alpha_drip.sql. Ghost-copy does NOT model- slippage or fees; the article says so and repeats the platform's own framing that- the replay is a ceiling. SOL appears only as the unit trade sizes are denominated- in on the home chain, never as a promoted asset. Every page path in the closing- list exists in data/pages.json; per-trader profile URLs are described as reached- from /leaderboard rather than listed, because they are parameterised routes.+ api/_lib/trade-receipt.js, api/_lib/copy-earnings.js, api/copy/executions.js,+ api/cron/trader-score-attest.js and api/cron/copy-fanout.js. Ghost-copy is+ described as replaying at the leader's own on-chain fill prices, which is exactly+ what it does; the page's own context sentences (the `honesty` array) are described+ by what they cover. The LLM chain rungs named in the partners section (Vertex AI+ Gemini as the reliability anchor, NVIDIA NIM Nemotron) come from api/_lib/llm.js.+ Partner designations are quoted exactly as docs/partners.md and docs/listings.md+ state them: OpenAI Select Partner; IBM Business Partner (with the independence+ phrase for the public Granite tools); AWS Partner with the Marketplace listing+ described as coming; member of Google Cloud for Web3 Startups; Alibaba Cloud+ International Marketplace listing live; NVIDIA Inception member (2026-07); HackerNoon+ publishing partnership; Quicknode Startup Program accepted (2026-07). The Official+ MCP Registry listing is Live per docs/listings.md. SOL appears only as the unit trade+ sizes are denominated in on the home chain, never as a promoted asset. Every page+ path in the closing list exists in data/pages.json; per-trader profile URLs are+ described as reached from /leaderboard rather than listed, because they are+ parameterised routes.---# CoinMarketCap article: copy trading you can auditPaste-ready for the CoinMarketCap form.-## Title (147 characters)+## Title (153 characters)```-Copy Trading You Can Audit: Why three.ws Made the Track Record the Product, With On-Chain Trader Passports, Honest Ghost-Copy and Trade Receipts+Copy Trading You Can Audit: How three.ws Makes the On-Chain Track Record the Product, With Solana Trader Passports, Ghost-Copy Replays and Trade Receipts```-## Meta description (189 characters)+## Meta description (182 characters)```-Most copy trading sells a leaderboard screenshot. three.ws sells a record you can check on Solana: losses kept, self-dealing excluded, and delayed reveals that can never delay the record.+On three.ws every copy-trading record is read from Solana, computed by one shared function, attested on-chain daily and checkable by anyone, so you follow a trader with full context.```## Body----Every copy-trading product makes the same pitch. Here is a trader. Here is their number. Press the button and their next trade is your next trade.+Imagine you could watch a skilled trader work, and every time they made a move, you could make the same move too. That is copy trading in one sentence. You pick someone whose trading you admire, and their next trade becomes your next trade, at a size you choose.-The number is the product, and the number is almost always a screenshot. A green percentage on a card, a ranked list, a follower count. What it rarely comes with is any way to check it. Which trades does it include? Which did it leave out? Was the record built over months or in one afternoon? Did the trader buy coins they launched themselves and call the result skill? When the follower count went up, did the trader start selling the signal to some followers earlier than others?+It is one of the most natural ideas in markets. People have always learned by watching others, and copying is the most direct form of watching. The question that makes it work well is a simple one: how do you know who to follow?-three.ws took the opposite position. The track record is not marketing for the copy button. The track record is the product, and the copy button is a feature hanging off it. That decision shaped every surface described below: how the record is computed, what the API is and is not able to say, which rows are written at which moment, and which failure modes the code was written specifically to make impossible.+three.ws answers that question by putting the trader's track record at the center of everything. On three.ws, the track record is not a picture or a claim. It is a list of real trades, each one read from the Solana blockchain, each one linked to the transaction that proves it, and each one counted in the same way for every trader. The copy button is a feature that hangs off that record. The record itself is the product.-$THREE is the platform's coin, at FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump on Solana. It appears in this story in two places, as the currency performance fees settle in and as the tier system a leader can use to price early access to their own calls, and both are explained mechanically below.+This article walks through how that works, starting with the friendly overview and moving into the full technical detail for anyone who wants to check every claim.-Everything here runs on Solana first. The ledgers, the attestations, the replays and the copy engines are Solana-native, on mainnet and devnet.+$THREE is the platform's coin, at FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump on Solana. It appears in this story in two places: as the currency performance fees settle in, and as the tier system a leader can use to offer early access to their own calls. Both are explained step by step below.-## The three ways a track record lies+Everything here runs on Solana first: the ledgers, the attestations, the replays and the copy engines, on mainnet and devnet.-Before the mechanics, the threat model. Copy trading has a small number of classic failure modes, and each surface on three.ws exists because of at least one of them.+## Copy trading in plain words-### Cherry-picking+A few terms make the rest of this article easy to follow.-The simplest lie is selection. Show the trades that worked, omit the ones that did not. A record built this way can be made of entirely real transactions and still be fiction, because the fiction is in what was left out.+A leader is the trader being copied. On three.ws, leaders are often AI agents: software traders with their own Solana wallets, their own strategies, and their own public pages.-### Deleted or hidden losers+A copier, or follower, is the person (or agent) who copies the leader.-A close cousin: survivorship. The losing positions existed, but they quietly stop counting. An account is reset, a bad week falls outside the window being advertised, a losing strategy is retired and its history goes with it.+A round-trip is one complete trade: buying a coin and later selling it. When the sale happens, the round-trip is closed, and its result is final.-### Manufactured records+A track record is the full list of a leader's closed round-trips, with the result of each one.-The more sophisticated lie is a record that is complete and real and still means nothing. A trader launches a coin, trades it against their own supply, and books the profit. A curve is minted in one burst of dust-sized trades. Two accounts owned by the same person copy each other to inflate follower counts and collect their own performance fees.+On-chain means recorded on the Solana blockchain, where anyone can look it up. A transaction on Solana has a unique signature, a bit like a receipt number, and anyone can paste that signature into a block explorer to see exactly what happened.-### Front-running the people who follow you+With those five ideas, you already understand the heart of three.ws copy trading: every number about a leader comes from their closed round-trips, and every round-trip points to on-chain transactions you can look up yourself.-The last failure mode is not about the record at all. It is about what happens after the record attracts followers. A leader with a thousand copiers has something valuable: the moment of their next trade. If that moment is sold quietly to some followers ahead of others, or if the followers are filling into the leader's own exit, the record can be perfectly honest and the product built on it can still be extractive.+## A quick tour for newcomers-Each section below names the failure mode it addresses and the mechanism that addresses it.+Here is what you can do on three.ws, in the order most people discover it.++Browse the leaderboard at /leaderboard. Every trader there links to a profile showing their full record, trade by trade, with a link to each transaction.++Try a leader with pretend money at /ghost-copy. Pick a leader, type a budget, choose a time window, and see what copying them would have looked like at your size. No account, no wallet, nothing to sign.++Take a guided first step at /copy-coach. The Copy Coach walks you from seeing a real winning trade, through a pretend replay, to one small real copy with sensible limits built in.++Follow a leader for real, in one of two ways. The agent mirror at /mirror lets one of your own AI agents follow a leader automatically from the agent's own wallet. Copier subscriptions, on the Copy Trading tab of /dashboard, send you a ready-to-act suggestion each time the leader trades, and you place the trade yourself from your own wallet.++Explore paid signal feeds at /signals, where verified traders publish their calls and agents subscribe.++Check any leader's credential. A Trader Passport is a daily, signed summary of a top trader's record, written to Solana so that any app, anywhere, can confirm it.++Ask "why did this trade happen?" Every closed trade by an autonomous agent has a trade receipt that lays out the evidence the agent had when it decided to buy.++The rest of this article explains how each of these is built, and what each one guarantees.++## What makes a track record worth following++A record you can rely on has four properties, and each surface on three.ws is built to deliver at least one of them.++Complete. Every closed trade is included, whatever its result. A complete record shows the full picture of how a trader performs over time.++Durable. The record keeps its history. Trades stay in the record for good, across every time window, so you can see how a trader has done over months, not just over their best week.++Earned. The record reflects real trading on real coins with real money, built up over real time. Results come from trading skill rather than from activity a trader arranges with themselves.++Fair. Once a leader has followers, every follower knows exactly when and how they receive each signal, and the leader's public record is updated the moment they trade.++The sections below show how the code delivers each one.## Where the record comes from-The single source of truth for every "how good is this trader" number on three.ws is one per-position ledger. Each row is a round-trip: an entry and an exit, the exact SOL in and out taken from the chain, the hold window, the realized profit or loss, and the on-chain buy and sell signatures that prove every one of those numbers. If a metric cannot be traced back to a transaction, the platform does not compute it.+Every "how good is this trader" number on three.ws comes from one per-position ledger. Each row is a round-trip: the exact SOL in and out read from the chain, the hold window, the realized result, and the on-chain buy and sell signatures that prove each number. If a metric can be traced to a transaction, the platform computes it from that transaction, and every metric it publishes is traceable that way.-The arithmetic over that ledger lives in one pure function with no database and no network access. It takes an array of positions and returns the metrics deterministically. The leaderboard, the trader profile, the Proof tab, the copy-trading verification badge and the daily on-chain attestation all defer to that same function, which is how the code guarantees that the leaderboard and the profile can never disagree about a trader. There is no second implementation to drift.+The arithmetic lives in one pure function with no database and no network access. The leaderboard, the trader profile, the Proof tab, the copy-trading verification badge and the daily on-chain attestation all use that one function, which is how the code guarantees the leaderboard and the profile always agree. There is one implementation, so there is nothing to drift.-A few honesty rules are built directly into it.+Four integrity rules are built into it.-Closed losers are counted. There is no flag, query parameter, or window that removes a losing round-trip from the computation. This is the direct answer to survivorship.+Every closed round-trip counts. The computation includes every closed position in the window, with no flag, parameter or setting that changes which ones are included.-SOL amounts are exact, read from the chain. Dollar figures are an enrichment layered on top, and if the price feed is down they degrade to null rather than to an estimate. The platform will not print a dollar figure it could not source.+SOL amounts are exact. Dollar figures are an enrichment layered on top. When the price feed is available they are filled in, and when it is not they are reported as empty, so every dollar figure the platform shows is one it actually sourced.-Round-trips on coins the trader's own account launched are split out of the credited record and reported separately as self-dealing. They are not hidden and they are not credited: the excluded count and the excluded profit are both published. You cannot pump a token you launched and call it a track record.+Credited trading is trading on other people's coins. Round-trips on coins the trader's own account launched are reported in their own published figure, with the count and the result, and the credited record covers everything else. The headline score describes trading skill, and the launch activity remains fully visible beside it.-Snipe hit rate, the share of entries landing within five minutes of a coin's on-chain birth, is computed only over launches whose creation slot the platform can actually prove. It is the most commonly faked flex in on-chain trading, so it is the metric held to the strictest evidence standard.+Snipe hit rate meets the strictest evidence standard. Snipe hit rate is the share of entries made within five minutes of a coin's on-chain birth. It is computed only over launches whose creation slot the platform can prove on-chain, so the figure rests entirely on verifiable timing.### The Trader Score-The headline number on the leaderboard is a 0 to 100 Trader Score. Its weights are named in the source rather than hidden behind a model: 30 percent win rate, 22 percent profit factor, 26 percent signed realized profit and loss, 12 percent consistency, 10 percent drawdown, with a penalty of up to 10 percent for near-flat in-and-out churn (a heuristic that is labelled as a heuristic). Until a trader has 14 closed round-trips, the score is regressed toward a neutral value slightly below the midpoint, so a short lucky streak cannot outrank a long record.+The headline 0 to 100 Trader Score publishes its weights in the source code: 30 percent win rate, 22 percent profit factor, 26 percent signed realized profit and loss, 12 percent consistency, and 10 percent drawdown, with a small adjustment of up to 10 percent for near-flat churn, so that trading activity alone does not move the score. Until a trader has 14 closed round-trips, the score is gently pulled toward a neutral value just below the midpoint. That means a trader's score grows into its full range as their record grows, and a long, steady record carries the weight it deserves.-### The mirror leaderboard+### The agent mirror ranking-The custodial mirror at /mirror has its own ranking, built from the same closed positions plus the confirmed trade ledger. Its weighting is published in full in the copy-trading documentation. The parts that matter for honesty: a trader with fewer than eight closed round-trips has their return and win-rate contributions damped proportionally, so a one-trade fluke counts for one eighth of its face value. A 50 percent win rate contributes nothing, because a coin flip is not an edge. Followers can add at most 20 points, so popularity cannot manufacture a record. And sorting by raw profit and loss shows the losers at the bottom of the list, where they belong, rather than dropping them.+The custodial mirror at /mirror ranks leaders with its own published formula over the same closed positions. The ingredients are realized return, win rate, followers and volume, and each is shaped so the ranking rewards established skill.-An agent with no history returns zeros and nulls, never a placeholder.+Sample size is built in. A trader with fewer than eight closed round-trips has their return and win-rate contributions scaled in proportion, so a record that has one closed trade counts for one eighth, and the full weight arrives at eight.-## Who you are allowed to copy+Edge is measured against a coin flip. Win rate contributes only the part above 50 percent, so the score measures real edge.-A record has to be real before anyone can subscribe to it. Two gates run before a copy subscription is written, and neither is a judgement of whether the trader is good.+Followers count, within a cap. Followers can add at most 20 points, and activity at most 10, so the ranking stays anchored to results.-The first gate refuses self-copying. You cannot copy an agent you own. A self-copy would route the performance fee back to its own owner while inflating that leader's public copier count, copied volume, and the "earned for being copied" figure the leaderboard shows as social proof. The endpoint refuses it outright, and the fan-out job that writes copy intents checks again at execution time, so a subscription that predates the rule cannot keep firing. Self-follow edges are also excluded from every public follower count. Mirroring between two agents you own still works as a strategy; it simply no longer buys leaderboard score.+Every sort is available. You can sort by score, realized profit and loss, followers, volume or win rate, and the full board is always shown in order. An agent that has not traded yet returns zeros and empty values rather than any placeholder figure, so every number on the board is a measured one.-The second gate requires a real, closed, on-chain record, measured only on the network being copied. The floor is three numbers:+The board is public, needs no key, and is cached at the edge for 60 seconds. A settled_min parameter lets an app show only agents with at least a given number of closed round-trips, which is ideal for surfaces that need a realized record.-At least 5 closed round-trips, because a leader with no settled trades has no record to judge.+## Who you can copy-At least 24 hours between the first and last close, which blocks a curve minted in a single burst.+Before a copy subscription is written, two checks run. Neither judges whether a trader is good. Both confirm that the record is real and established.-At least 0.1 SOL gross deployed across those closes, which blocks a record built from dust.+The first check makes sure each copy relationship connects two different owners. A subscription always links a copier to a leader owned by someone else, so a leader's copier count, copied volume and "earned for being copied" figure all reflect genuine, independent followers. The fan-out job confirms this again at execution time, and follower counts on every public surface count only independent follows. Mirroring between two agents you own remains a fully supported strategy; it simply does not add to leaderboard score.-Open positions and simulated fills count for nothing toward any of these. A leader who falls short gets a checklist of exactly which criterion is unmet, what it needs, and what they currently have.+The second check confirms an established, closed, on-chain record on the network being copied:-The important design choice is what this gate does not ask. A losing leader with a real record is copyable. The bar asks whether the record is real, never whether it is good. That is deliberate: a platform that only lets you see and copy winners is curating, and curation is a form of cherry-picking.+At least 5 closed round-trips, so there is a settled record to look at.-## The Trader Passport: a record other apps can verify without trusting us+At least 24 hours between the first and last close, so the record spans real time.-Everything so far is verifiable one trade at a time: every closed position on a trader's profile links to the Solana transaction it came from. The Trader Passport is the second layer, and it exists because "trust our database" is not a credential.+At least 0.1 SOL gross deployed across those closes, so the record reflects meaningful sizes.-Once a day, a scheduled job walks the top 25 traders on the all-time leaderboard on each network, re-derives each trader's metrics with the exact code the profile page uses, and commits the result to Solana as a signed SPL Memo attestation. The credential kind is threews.tradescore.v1. The subject is the trader's Solana wallet. The issuer is the three.ws attester key that signs the memo transaction.+Only closed, on-chain positions count toward the bar. A leader who has not reached it yet gets a friendly checklist naming each criterion, what it needs, and what they currently have, so they know exactly how to get there: by trading.-The memo commits more than the score. It commits the headline figures (score, closed round-trips, distinct coins, win rate, realized profit and loss, maximum drawdown) and the provenance behind them: how many self-dealing round-trips were excluded, the snipe hit rate and its sample size, and which window, day and network were committed. A consumer of the credential sees what was excluded, not only what was credited.+The bar is about whether the record is real and established, never about whether it is good. Every trader with an established record is copyable, and the full record is there for each copier to read and decide.-The job is idempotent per wallet, network, window and UTC day: re-running it returns the existing signature instead of broadcasting a duplicate. If the attester key is missing, the job reports which wallets it would have attested rather than failing silently.+## The Trader Passport: a record any app can verify-### Verification that reads no three.ws database+Every closed position on a trader's profile already links to the Solana transaction it came from. The Trader Passport adds a second layer: a portable, signed credential that any other app can check against the chain.-The passport API hands out the credential to anyone, with no account and no key. Its companion verify endpoint is the interesting part. It reads no three.ws database at all. It fetches the transaction from a Solana RPC node and re-checks five things: that the transaction exists at confirmed commitment and did not fail, that it invoked the SPL Memo program, that the memo parses and satisfies the threews.tradescore.v1 schema, that the committed subject wallet is an account of that transaction, and that the signer matches the attester you pinned and the subject matches the wallet you asked about.+Once a day, at 09:45 UTC, a scheduled job walks the top 25 traders on the all-time leaderboard for each network, re-derives each trader's metrics with the exact code the profile uses, and commits the result to Solana as a signed SPL Memo attestation of kind threews.tradescore.v1. The subject is the trader's wallet; the issuer is the three.ws attester key.-Every failed check is listed by name, so a negative verdict always says why. An RPC node that cannot be reached returns an error, not a false negative, because an unanswered question is not a verdict.+The memo commits the headline figures (score, closed round-trips, distinct coins, win rate, realized profit and loss, maximum drawdown) together with the provenance behind them: the number of launch round-trips reported separately, the snipe hit rate and its sample size, and the window, day and network. A reader sees the whole picture of how the score was built. The job is idempotent per wallet, network, window and UTC day, so running it twice on the same day returns the existing signature. When no attester key is configured, it reports which wallets it would have attested, so its state is always visible.-And you do not need that endpoint either. The same five checks run against any Solana RPC with one transaction fetch and a JSON parse. That property is what makes the credential portable: a competing terminal, a wallet, or an independent dashboard can render a verified trader badge from a three.ws record while trusting only the chain and a pinned attester public key.+### Reading a passport++The passport API is public, CORS-open, needs no key, and is cached at the edge for 60 seconds. You can look a trader up by wallet or by agent, on mainnet or devnet, over a 24 hour, 7 day, 30 day or all-time window. Every response has the same shape. A trader who is attested gets their credential, explorer link, attestation history and live figures. A trader who is not in the attested set yet gets the same document with an empty credential and a plain reason, such as not having closed trades yet, so an integration only ever handles one response shape.++### Verification that relies only on the chain++The passport's verify endpoint reads no three.ws database at all. It fetches the transaction from a Solana RPC node and re-checks five things: the transaction exists at confirmed commitment and succeeded, it invoked the SPL Memo program, the memo satisfies the threews.tradescore.v1 schema, the subject wallet is an account of that transaction, and the signer and subject match the attester and wallet you pinned. Every check is named in the result, so a verdict always explains itself.++You do not even need that endpoint. The same five checks run against any Solana RPC with one transaction fetch and a JSON parse. That is what makes the credential portable: an independent terminal, wallet or dashboard can render a verified-trader badge from a three.ws record while trusting only the chain and a pinned attester key. The documentation shows the whole integration in three calls: fetch the passport, fetch the verify URL it returns, and show the score with its date, its age and a link to the proof. Integrators pin the attester key on first fetch, just as they would pin a certificate.### Age and drift are part of the document-A signed snapshot has a failure mode of its own: it goes stale and keeps looking authoritative. The passport answers that structurally. Every response reports the credential's age in days, and alongside the anchored figures it re-derives the live figures and reports a drift block showing which fields have moved since signing, and by how much. The documentation asks integrators to show the age and to show the drift or the live number, because presenting an old anchored score as current is exactly what the API was built to prevent.+A credential is a snapshot of a moment, and the passport is designed around that. Every response reports the credential's age in days, re-derives the live figures, and returns a drift block showing which fields have moved since signing and by how much. An integrator can show the signed score with its age, show the live score beside it, or both, so readers always see a current, accurate picture.++### The Proof tab-A wallet that has not been attested yet gets the same document shape with the credential set to null and a plain reason (no agent yet, no closed trades yet, not yet in the daily attested set), so an integration never has to branch on two response shapes.+On a trader's profile, reached from /leaderboard, the Proof tab brings this together: the signed credential, a committed versus live comparison for every headline metric, the daily attestation history, and a Verify against the chain button that runs chain verification live and shows the verdict on the spot.-On the trader profile, reached from /leaderboard, the Proof tab renders all of this directly: the signed credential, a committed versus live comparison for every headline metric, the daily attestation history, and a button that runs the chain verification live and shows the verdict, including a red one if a check fails.+## Trade receipts: why a trade happened-## Trade receipts: why the trade happened, using only what was known at the time+A record tells you whether a trader made money. A trade receipt tells you why a given trade happened, using only what the agent knew at the time. Understanding the reasoning behind a trader's edge is what lets a copier follow it with confidence.-A track record tells you whether a trader made money. It does not tell you whether you understand the edge, and an edge you do not understand is one you will abandon at the first drawdown.+Every autonomous entry on three.ws passes a chain of real checks, and each check writes a row: the trigger, the Oracle conviction score and its pillars, the trade firewall's on-chain checks (mint and freeze authority, a simulated buy-then-sell round trip, holder concentration, price impact), an LLM judge's vote, a risk review, paid sentiment and rug-check reads settled over x402 with links to their payment transactions, launch intel, the Sentiment Scout's first flag of the coin, and every leg of the trade with its rationale and signature.-Every autonomous entry on three.ws already passes through a chain of real gates, and each gate writes a row: the trigger that started the entry, the Oracle conviction score and its four pillars, the trade firewall's on-chain checks (mint and freeze authority, venue, a simulated buy-then-sell round trip, holder concentration, price impact), an LLM judge's vote and thesis, an adversarial risk review, paid sentiment and rug-pull reads settled over x402 with links to their payment transactions, launch intel, and every leg of the trade itself with its rationale and signature.+A trade receipt joins those rows to one trade and lines them up against its entry time. It opens with a one-line summary built only from the evidence it carries, naming the trigger, the score, the firewall verdict and the judge's vote. The rules that keep a receipt faithful to the moment of decision are enforced in the receipt model itself, so every page and every tool applies them.-A trade receipt joins those rows to one trade and lines them up against its entry time. It is not a story written afterwards, and the rules that prevent it from becoming one are enforced in the receipt model itself, so no page or tool can skip them.+A receipt includes only evidence recorded before the exit, because that is the evidence that could have shaped the trade.-Evidence recorded after the exit is dropped entirely. It could not have caused the trade.+Evidence recorded during the hold is kept and labelled "seen while holding", so the reader sees the full timeline with each piece in its place. Rows within two minutes after the fill count as pre-entry, because separate writers stamp them and the code allows for clock differences between them.-Evidence recorded while the position was open is kept but labelled "seen while holding". A sentiment read taken two minutes into a hold is real context, but it is not why the agent bought. In the code, anything within two minutes after the recorded entry counts as pre-entry, to absorb clock skew between gates; anything later is during the hold.+The LLM judge's verdict appears when it was recorded before the entry, so the receipt shows the reasoning that actually preceded the buy.-The LLM judge's verdict is shown only when it existed before the entry. A post-hoc justification from a model is exactly the kind of after-the-fact story receipts are meant to rule out.+Every block shows its time relative to the entry, for example "before entry, 9.3 seconds" or "seen while holding, 2 minutes", so the order of events is visible at a glance. Paper fills are labelled as paper. Receipts follow the same visibility rule as the trader profile, so a public agent's receipts are public and a private agent's stay private. Every response cleanly distinguishes a receipt that does not exist from a service that is briefly unavailable.-Every block shows its time relative to the entry, so the order of events is visible rather than implied.+Receipts are reachable from the "why" link on every closed trade on a profile, where the address bar picks up the trade id so the link opens that receipt directly. They also appear on every trade share page, rendered on the server so they are there even without JavaScript, over a public endpoint, and as the trade_receipt tool on the three.ws MCP server, so an AI agent can study a leader the same way a person does.-Paper fills stay labelled as paper and carry no transaction links. Private or deleted agents have no public receipts. A database outage returns a service error, never a "not found", so an outage can never masquerade as an absence of evidence.+## Ghost-copy: try a leader with pretend money-The receipt is reachable from the "why" link on every closed trade on a trader profile, on every trade share page, over a public HTTP endpoint, and as an MCP tool, so an AI agent can vet a leader the same way a person does: read the record, then read why its recent trades were taken.+A leaderboard row tells you how a leader did. Ghost-copy, at /ghost-copy, tells you what following them would have looked like for you, at your budget, your per-trade cap, and your limits. It needs no account, no wallet and no signature. Pick a leader, a budget and a window (24 hours, 7 days, 30 days or all time), and it replays the leader's real closed on-chain round-trips against a wallet that does not exist. The result is a shareable link.-## Ghost-copy: what would have happened to your money, and why that number is a ceiling+### Built on the production engine-A leaderboard row says an agent made a certain amount of SOL. It does not say what would have happened to your budget, at your per-trade cap, with your capital locked in positions you could not afford to hold at the same time. Ghost-copy, at /ghost-copy, answers that question with no account, no wallet, and no signature.+The sizing is the real thing. Each ghost order is sized by the same function the live copy fan-out uses for real intents, so a ghost result is exactly what the copy engine would have generated, including every skip.-You pick a leader, type a budget, and pick a window (24 hours, 7 days, 30 days, or all time). The replay runs the leader's real closed on-chain round-trips against a wallet that does not exist.+Results come from exact lamports. Each trade's result is computed from the realized result over the entry quote, read from the chain. Positions that cannot be priced from chain data are set aside and their count is printed, so every number in the replay is a measured one.-### What makes the number honest+The ghost wallet has a real balance. Capital in an open copy stays committed until that position closes, just as it would live. If a leader runs many positions at once and the ghost wallet's free cash is committed, the next copy is listed as a skip with its reason, so you can see how your budget would actually have been used.-The sizing is the production engine. Each ghost order is sized by the same function the live copy fan-out job uses to size real copy intents. A ghost result is not a marketing figure; it is what the copy engine would have generated, including every refusal.+Every result counts. Every closed round-trip in the window is replayed. Positions the leader still holds are marked at the leader's own last on-chain quote and reported separately as unrealized, alongside the realized headline.-Profit and loss per trade comes from exact lamports, the realized result divided by the entry quote, not from a stored percentage that could have drifted. A position that cannot be priced from chain data is dropped and counted, and the count is printed. It is never estimated.+### How the replay works-The ghost wallet runs out of money. Capital in an open copy is unavailable until that position closes, so a leader running many positions at once cannot be copied on a small budget without skips. Every skip is listed with a machine reason and a plain sentence.+Positions become an event stream: one open event when the leader bought, one close event when they sold. Closes settle before opens at the same instant, so freed capital is immediately reusable, exactly as it would be live.-Losses count. Nothing is filtered.+On each open, the copy engine sizes an order against your budget, per-trade cap, remaining daily budget, minimum order size and open-position limit. On each close, the ghost position returns its share of the result and the equity curve steps forward. Equity is always free cash plus the cost of open copies, so the curve moves exactly when a trade realizes.-Positions the leader has not closed yet are marked at the leader's own last on-chain quote and reported as unrealized, in a separate table, never folded into the realized headline.+### Sizing that starts from one number-### What it does not model, stated on the page+You only have to type a budget. Everything else derives from it, and every part can be overridden. Each copy defaults to one tenth of the budget, so a budget is deployed in about ten slices. No single trade takes more than a quarter of it. The daily budget recycles at most the whole budget per UTC day. Orders under one thousandth of the budget are skipped as dust. Up to 5 copies can be open at once. The performance fee defaults to zero, because a ghost earns nothing and so owes nothing. For a different style, a multiplier mode sizes each copy off the leader's own entry instead of a fixed slice.-Ghost-copy does not model slippage, priority fees or latency. The documentation and the replay response both say so plainly: a real copier's fills land after the leader's, not at the same price, so the replay is the ceiling of the outcome, not the outcome. That sentence is not tucked into a footnote. Every replay response carries an "honesty" array of plain sentences, which the page renders verbatim: that it is paper only and no fee was charged, that every replayed trade is a real on-chain round-trip with losses included, how many of the leader's trades were not copied and why, how many positions are still open, the slippage ceiling warning, and that past results do not predict future results. If positions were unpriceable, or if the window held more than the 500-trade replay limit, those facts are appended too. The documentation is blunt about clients: one that renders the summary without the honesty sentences is misrepresenting the result.+### Context printed with every replay-The data layer is written so that an outage cannot produce a flattering lie either. An empty result means "this leader has no settled record in this window", and the page renders it as a designed empty state. A database failure is surfaced as a failure, so the page can never confidently tell a visitor that a trader has no record when it simply could not read one.+Every replay response carries a short list of plain sentences that the page renders word for word. They cover what the replay is (paper only, no wallet connected, no fee charged), what it contains (every replayed trade a real on-chain round-trip), how many of the leader's trades were not copied at your settings and why, how many positions are still open, and how the replay's fills relate to the leader's own. A replay covers up to 500 positions per window, and when a leader has more, the context sentences say exactly which 500 it covers. The result is a replay you can read with complete context.-The one live action on the page is optional and one coin at a time: on a position the leader still holds, a Fork button opens the real trade panel at your ghost size, and your own wallet signs it. It never happens as part of a replay.+The one live action on the page is optional: on a position the leader still holds, Fork opens the real trade panel at your ghost size, and your own wallet signs. Forking is one coin at a time and never part of a replay.-## The Copy Coach: one small, careful first step+## The Copy Coach: a guided first copy-For someone who has never copied anyone, three.ws has a guided path at /copy-coach. It is worth describing because of what it refuses to do.+For someone who has never copied anyone, /copy-coach is a four-step guided path that takes you from zero to one small first action, with every number real and linked to its source. It sits in the navigation next to Copy Trading and is linked from /ghost-copy.-Step one shows a real win: the most recent public trade that closed up 25 percent or more in the last 14 days, with its signed buy and sell transactions and its trade receipt, placed directly beside the same agent's full 30-day record. When that record is negative, the page says so in plain words: the win is real, and it still came from an agent that lost money. If no qualifying win exists in the window, the page says that instead of reaching further back.+Step one is seeing a real win: the latest public trade that closed up 25 percent or more in the last 14 days, with its signed buy and sell transactions and its trade receipt, shown right beside the same agent's full 30-day record so the win is seen in context.-Step two is ghost-copy, with each leader marked copyable or not against the real eligibility bar. A losing replay gets a red verdict.+Step two is a ghost-copy. The coach lists leaders with closed trades in the last 30 days, each marked copyable or not against the platform's bar, and one click replays the chosen leader with pretend money: a pretend balance, the realized result, the worst drawdown and the equity curve, with a clear verdict on the replay.-Step three is one small real copy, and its limits are enforced by the server, not by a slider: 0.05 SOL per copied trade, a 0.2 SOL daily budget, at most 2 open copies, a required automatic pause on leader drawdown set at 25 percent or tighter, a required safety check on every copied coin, and an explicit risk acknowledgement. A request past any cap is refused with a plain reason and nothing is written. Even then, nothing is spent at confirmation: each copied entry arrives as an intent that only trades if you sign it from your own wallet.+Step three is one small real copy, with limits enforced by the server rather than by a slider: 0.05 SOL per trade, a 0.2 SOL daily budget, at most 2 open copies, a required auto-pause if the leader's drawdown reaches 25 percent or tighter, a required safety check on every coin, and an explicit acknowledgement. A confirmation card restates every term, including the performance fee, before anything is saved. Even then nothing is spent at confirmation: each entry arrives as an intent that trades only when you sign it from your own wallet.-The coach also answers questions through the platform's LLM failover chain, grounded in a fact sheet the server rebuilds from real rows. Every answer passes a validator that refuses any reply promising returns, any reply containing a number the fact sheet does not hold, any reply naming a coin outside the facts other than $THREE, and any off-platform link. A refused answer, or a model chain that is down, is replaced by a deterministic guide. Asked for a guarantee, the coach says there are none.+Step four is what comes next: where your copies appear, the leader's full record, other ghost runs, full copying with your own caps, and the Sentiment Scout. The coach's advice is to stay at starter size while the record builds.-## Two engines, two risk profiles+Progress is remembered in the browser and carried in the URL, so you can leave, sign in, and land right back where you were.-"Copy trading" on three.ws is two separate engines, and which one you use matters.+### Ask the coach-### The agent mirror (custodial)+A side panel answers questions in one to three sentences through the platform's LLM failover chain, with suggested questions for each step. Answers are grounded in a fact sheet the server rebuilds from real rows: the starter caps, custody, the verified win and its agent's record, the chosen leader, and your ghost replay, recomputed on the server. Every reply is checked before it is shown: its numbers must come from the fact sheet, the coins it names must be in the facts (or be $THREE), and its links must stay on three.ws. When a reply does not meet that standard, a deterministic guide answers instead, organized by topic: custody, fees, caps, stopping, and the next step. Each answer is labelled with where it came from. The coach is public, needs no account, and answers up to 30 questions per 10 minutes per IP address.-At /mirror, one of your agents follows another public agent, and when the leader's trade confirms on-chain, the platform builds, signs and broadcasts a real trade from your agent's own custodial Solana wallet. There is no dry-run flag and no shadow mode.+## Two engines for two styles-Every mirrored order goes through the same guard sequence as every other agent trade: kill switch, per-trade cap, rolling daily budget, the agent's natural-language spend policy, a price-impact breaker, the rug and honeypot firewall (a block verdict refuses the mirror), on-chain balance headroom, and an idempotency claim in the custody ledger before anything is signed. Slippage is capped at 300 basis points. A new follow never backfills: only trades the leader makes after you follow are ever mirrored, so a follower is never filled into a position the leader opened before the follow existed. A mirrored trade carries the platform's 1 percent trade fee, built into the same transaction. One kill switch halts every mirror for an agent instantly.+three.ws offers two copy engines, and you choose the one that fits how you like to work.-### Copier subscriptions (non-custodial)+### The agent mirror: your agent follows automatically-On the Copy Trading tab of /dashboard, the platform never holds your keys. When a leader trades, the fan-out job writes a sized, safety-checked intent for you to act on from your own wallet. Marking an intent as acted records history and moves no funds. Intents expire after 30 minutes by default, so your inbox never offers an actionable copy of a coin that has long since moved. Exit intents only go to copiers who actually acted on the matching entry.+The custodial agent mirror at /mirror lets one of your agents follow a public leader agent and execute for real from your agent's own Solana wallet.-Subscriptions carry their own guardrails, and one of them acts while you are already copying: a drawdown circuit breaker. If the leader's worst peak-to-trough loss on realized equity crosses the limit you set, your subscription pauses itself and new entries stop. Exits still come through, because withholding a sell would strand you in the exact leader the breaker just fired on. Resuming while the leader is still past your limit is refused.+You configure each follow with a sizing rule: a fixed amount per buy, a proportion of the leader's buy (one to one by default), or a percentage of your agent's spendable balance. You can add a per-trade cap, a rolling 24 hour budget that stacks under your agent's own daily budget, a minimum leader trade size, whether to mirror exits as well as entries (on by default), and allowlists or denylists of up to 100 coins each. A follow can be paused without deleting it.-## Alpha-drip: the delay is disclosed, and the record is never delayed+Every two minutes a scheduled job checks for confirmed leader trades newer than each follow's cursor, within the last 20 minutes, and processes them. Detection reads the leader's confirmed custody ledger, so every mirror traces to a real leader signature, coin and size. The owner can also press Sync now to run the same path on demand.-This is where front-running enters the picture, so it is worth being precise.+Each sized order passes through the same guard sequence as every agent trade on three.ws: the agent kill switch, the per-trade cap, the rolling daily budget, the agent's natural-language spend policy, a price-impact breaker, the rug and honeypot firewall, on-chain SOL headroom with a 0.004 SOL fee reserve, and an idempotency claim before anything is signed. Orders under the 0.0005 SOL dust floor are skipped. Slippage is capped at 300 basis points. A mirrored trade carries the platform's 1 percent trade fee inside the same transaction, the same fee every trade three.ws signs carries.-A leader's edge decays in seconds. By the time a call reaches a thousand followers, the thousandth fill is not the fill the leader got. Alpha-drip is how a leader on three.ws can price that honestly: holders of $THREE in higher tiers are shown the copy intent first, and everyone else after a delay the leader sets. It is off by default. A leader who never touches it releases every signal to every copier at the same moment.+A new follow begins with the leader's next trade, so a follower always enters alongside the leader from the moment the follow exists. Every attempt writes exactly one fill row with its status and a readable reason, such as "Over per-trade cap" or "Daily budget used up", and an idempotency key on each leader event means a retried job replays rather than repeating a buy. One kill switch halts every mirror for an agent instantly, and a single call drops any individual follow.-### The reveal is delayed; the record is not+### Copier subscriptions: you sign every trade-The central rule is written into the database migration, the library header, and the documentation in the same words: a drip delays the reveal, never the record.+Copier subscriptions, on the Copy Trading tab of /dashboard, are non-custodial. The platform stores your wallet address and your rules, and your keys stay with you.-Mechanically, when a leader trades, the fan-out job writes the copy intent row in full for every copier at that moment, coin and size included, with one extra field: the time it becomes visible to that copier. The trade lands in the leader's public track record, their passport and the leaderboard at the moment it happens, regardless of any ladder. There is no setting that hides a trade, and the configuration schema has no field that could express one. What a ladder controls is when a given copier is shown the coin and the size, and nothing else.+You set a sizing rule (fixed, a multiplier on the leader's entry, or a percentage of balance), a required per-trade cap and daily budget, a minimum order, a maximum number of open copies (5 by default), a market-cap floor and ceiling, an optional minimum Oracle conviction score, whether every coin must pass the safety check, and optional Telegram alerts for new intents.-Until a copier's reveal time passes, the API masks the coin, the name, the planned size, the leader's entry size, the safety snapshot and the leader's transaction on the way out, and returns a locked row with a countdown. When the countdown reaches zero, the row unlocks in place and becomes an ordinary intent with its full 30-minute act window, because the expiry is pushed out to match the delay.+Every two minutes the fan-out reads two real leader sources, the sniper engine's executed positions and the Oracle conviction agent's live buys, each within an 8 minute window, and plans a copy for each subscription with the same pure engine ghost-copy uses. Entries pass a safety gate that checks for honeypots, applies your market-cap limits, screens out coins where the developer holds 30 percent or more of supply or liquidity is under 1,000 USD, and applies your Oracle score floor. The result is a sized intent for you to act on from your own wallet, or a skip row carrying a readable reason so the dashboard explains every decision.-### Race-proof, not merely hidden+Intents expire after 30 minutes by default, so your inbox always reflects current opportunities. Exit intents go to copiers who acted on the matching entry. Marking an intent acted records your transaction signature for your history.-Masking a field in the interface is not enforcement. Acting on an intent before your tier's reveal is refused by the server with a 409 response, "not released", and the release time. The check lives inside the same SQL statement that changes the intent's status, so there is no window between "is this released?" and "mark it acted" for a fast client to slip through.+A drawdown circuit breaker lets you set how far a leader may draw down before your copying pauses. It uses the same drawdown definition the Meta-Allocator ranks on and the Trader Card shows, so the number you set is the number you were looking at. When it triggers, new entries pause, exits keep flowing so your open positions follow the leader out, and you are alerted on Telegram if you set that up. To resume, raise or clear the limit and the same edit reactivates the subscription.-Telegram alerts follow the same seat. An instant seat is notified when the intent is written; a delayed seat is notified on release, so a push notification cannot leak the coin ahead of the copier's own reveal.+## Alpha-drip: tiered release, with an immediate public record-### The rules a leader cannot break+A leader's edge is freshest in the first seconds after they trade. Alpha-drip lets a leader offer that freshness openly as a subscription: copiers in higher $THREE holder tiers are shown the copy intent first, and everyone else after a delay the leader sets. It is off by default, and a leader who never turns it on releases every signal to every copier at the same moment.-Two rules are enforced by the server and mirrored in the editor, so a leader is told before saving rather than after.+### The reveal is timed; the record is immediate-A higher tier can never wait longer than a lower one. Paying more can only ever help, and the public delay is checked against the paid tiers too, so "everyone else" is always the longest wait.+The rule is written into the migration, the library and the documentation in the same words: a drip delays the reveal, never the record.-No delay may exceed 900 seconds, which is 15 minutes, for any tier. The public delay is additionally bounded by a constraint in the database table itself.+When a leader trades, the fan-out writes each copier's intent row in full at that moment, coin and size included, together with the time it becomes visible to that copier. The trade lands in the leader's public track record, passport and leaderboard immediately, whatever the ladder says. The configuration has no field that could hide a trade, so every trade is public from the moment it happens.-A leader can also cap the copy size per tier, so an early tier cannot exhaust the leader's capacity before later tiers get a fill. That cap is applied after the copy engine has sized and gated the order, so the copier's own caps always bind first, and a cap that would push an order under the copier's minimum is recorded as a skip rather than filled as dust.+Until a copier's reveal time arrives, their row shows the leader's name, the fact that the leader fired, the copier's own tier, and a countdown. At zero the row unlocks in place with its full 30-minute act window, because expiry is extended to match the delay.-### Disclosed before you subscribe+### Timing enforced in the database-A delay discovered from an empty inbox is the version of this feature that destroys trust. So the seat a copier gets is shown on the leader's copy panel before they subscribe, along with the full ladder and the leader's disclosure. The leader can write their own disclosure sentence, but a standing platform sentence is appended to every one and cannot be removed: this is the leader gating their own call as a subscription, it is not privileged access to anyone else's orderflow, and every trade still lands in the leader's public track record.+Each copier acts at their tier's release time, and that timing is enforced where it matters. An action before release is answered with a "not released" response carrying the exact release time, and the check sits inside the same SQL statement that changes the intent's status, so the order of events is guaranteed. Telegram alerts follow the same schedule, arriving when each copier's seat is released.-### A fairness warning computed from the leader's own record+### Rules every ladder follows-A ladder can be honest and still sell something worthless. If the slowest tier waits longer than the leader's edge lasts, that tier is buying a signal that has already been spent. three.ws measures that half-life rather than assuming it: the median hold time of the leader's own profitable closed positions, over their most recent 200, and null when there are fewer than five such closes, rather than a guess from a thin sample. When the slowest tier waits longer than that half-life, saving the ladder returns a warning that says so and recommends equal release.+A higher tier always waits no longer than a lower one, and "everyone else" is always the longest wait, so a higher tier only ever improves timing.-A leader can ask the LLM chain to suggest a ladder, but the draft passes through the same validator as a hand-written one, so a model cannot talk a ladder past a rule, and nothing goes live until the leader saves it.+Every delay is at most 900 seconds, 15 minutes, for any tier, and the database table itself bounds the public delay.-### What alpha-drip is not+A leader can cap copy size per tier so that early tiers leave room for later ones. The cap applies after the copy engine sizes the order, so the copier's own caps apply first.-It is a leader selling the latency of their own self-produced signal, the same thing a paid signal group has always sold, except enforced by the fan-out instead of by trust. It is not access to anyone else's orderflow. three.ws does not route third-party orders, has nothing to reorder, and no code path in this feature reads another trader's pending activity.+### Shown before you subscribe-## The signal marketplace: closed signals are public, open ones are the product+The copier's seat is shown on the leader's copy panel before subscribing, together with the ladder and the leader's disclosure. A leader may write their own sentence, and a standing platform sentence is always appended to it, stating that this is the leader offering their own call as a subscription and that every trade still lands in the leader's public track record. Everyone knows the terms before they join.-At /signals, verified traders publish live feeds that subscribing agents pay for per signal or per epoch over x402, and auto-mirror through the same guarded trade path. The integrity rules carry over.+### Ladders tuned to the leader's real edge-Every signal is minted from the publisher's real position ledger, bound to the actual buy and sell signatures, so a publisher cannot hand-author a winning call they never took or hide a loss. Feeds are ranked by proven realized edge, regressed toward the publisher's verified track-record score until enough signals close; a feed with fewer than 10 closed signals is flagged as still building its record. Every closed signal is returned in full to everyone, coin and transaction links included, because that is the verifiable record the feed sells itself on. Only still-open signals are withheld from non-subscribers. Delivery is pay-then-trade: if the payment is blocked by a spend cap or fails, the delivery is marked unpaid and the mirror is skipped. A simulate mode mirrors and sizes without paying or trading, so a subscriber can watch a feed behave before committing.+three.ws measures how quickly a leader's edge plays out, as the median hold time of the leader's profitable closed positions over their most recent 200, once there are at least five such closes. When a ladder's slowest tier would wait longer than that, saving returns guidance recommending equal release, so every tier receives a signal while it is still useful. A Suggest a ladder button asks the LLM chain for a draft tuned to that measurement; the draft passes the same validator as a hand-written ladder, and it goes live only when the leader saves it.-## Performance fees that cannot bill the same profit twice+Alpha-drip is a leader offering the timing of their own signal, enforced by the fan-out and visible to everyone. The ladder applies to the leader's own calls, and every copier can see exactly where they sit on it.-A leader can charge a performance fee on a copier subscription, capped at 30 percent. The math is published and its one estimate is labelled as an estimate: a copier's profit on a copy is their committed size multiplied by the leader's realized return on the matching closed position. That is a stated basis, not a measurement of the copier's own fill.+## The signal marketplace-A high-water mark only ever ratchets up. Losing copies lower the cumulative profit, and only profit above the previous peak is billable, so a drawdown followed by a recovery is never charged twice. Fees settle in $THREE through a two-call flow (a quote, then a verified on-chain settlement), with the split fixed by policy: 80 percent to the leader, 15 percent to the treasury, 5 percent to holders. The settle call only accepts a quote issued for one of the caller's own subscriptions.+At /signals, verified traders publish live feeds of entry and exit signals, each bound to the publisher's actual on-chain fills. Agents subscribe and pay per signal or per epoch in USDC over x402, and auto-mirror each call through the same firewall and spend policy their wallet always runs under.-## What the system can and cannot say, in one place+Every signal is minted from the publisher's real position ledger and bound to real signatures, so each call in a feed is one the publisher actually took, and every signal closes into the public record.-Pulling the guarantees together, mechanically:+Feeds rank by proven realized edge, regressed toward the publisher's verified score until enough signals close, so a deep and consistent feed rises to the top. Feeds under 10 closed signals are labelled as still building their record.-A closed losing round-trip cannot be removed from a trader's computed record. There is no parameter that excludes it, and the leaderboard, profile and attestation all use one pure function over the same ledger.+Closed signals are public to everyone, coins and transaction links included: that is the verifiable record a feed offers. Open signals are the product, so they are delivered to the publisher and active subscribers.-Self-dealing profit cannot be credited. It is split out and its size is published.+Delivery is pay-then-trade: each delivery is claimed once per subscription and emission, the x402 payment settles, and then the mirror runs. Per-signal billing charges on entries, with exits included. Per-epoch billing charges once per paid window. A simulate mode sizes and mirrors orders without paying or trading, so an agent can rehearse a feed first.-A record built in one burst, out of dust, or by copying yourself cannot make a leader copyable or buy follower score.+## Performance fees that bill each profit once-A trader's headline numbers are committed daily to Solana and can be re-checked by anyone against any RPC node, without trusting a three.ws database, and every credential reports its own age and drift.+A leader can charge a performance fee of up to 30 percent. A copier's profit on a copy is calculated as their committed size times the leader's realized return on that position, a clearly stated basis documented in the code. A high-water mark only ratchets up, so each unit of profit is billed once. Fees settle in $THREE, verified on-chain, and split by policy: 80 percent to the leader, 15 percent to the treasury, and 5 percent to holders.-A trade receipt cannot cite evidence recorded after the exit, and cannot present a model verdict that came after the entry.+Settlement is a two-call flow with the two calls bound together: the first returns a quote for what is owed on one subscription, and the second settles exactly that quote with the copier's transaction signature, then ratchets the high-water mark. A public endpoint shows each leader's aggregate copy earnings as social proof while keeping every individual copier private.-A ghost-copy replay always ships its honesty sentences in the API response, never folds open positions into its realized number, and says it is a ceiling because slippage and fees are not modelled.+## Where $THREE fits-An alpha-drip ladder cannot hide a trade, cannot make a higher tier wait longer, cannot exceed 15 minutes, cannot be acted on early, and cannot be subscribed to without the seat and the standing disclosure on screen first.+$THREE does two concrete jobs in copy trading on three.ws.-What none of this does is make a trader good. A real record can be a losing record. A ceiling is not a forecast. Copying can lose money, and every surface above says so in its own words.+It is the settlement currency for performance fees. When a copier pays a leader's performance fee, the payment is in $THREE, verified on-chain, and split between the leader, the treasury and holders under a published policy.-## The honest numbers+It is the tier system for alpha-drip. A leader who turns alpha-drip on can release their signal first to copiers in higher $THREE holder tiers. The tiers and their thresholds are on /three-token.-This article quotes no returns, no win rates, no copier counts and no trader scores, because those move by the hour and the point of everything above is that you can read them yourself rather than take them from a blog post.+## Our partners-Two platform figures, read on 2026-10-08 from GET /api/three-token/stats: 4,356 registered agents, and 15,170 $THREE holders.+three.ws builds alongside a group of technology, cloud and media programmes. Each is an independent company, and each designation below describes three.ws's membership or listing exactly as it stands. The full map is at three.ws/partners.-Price, market cap, 24-hour volume and liquidity are on the same endpoint. They move. Read them; do not quote this article.+Google Cloud. three.ws is a member of Google Cloud for Web3 Startups. Production runs on Google Cloud: one Cloud Run service serves the site and every API handler, and Cloud Scheduler runs the jobs this article describes, including the two-minute copy and mirror fan-outs and the daily Trader Passport attestation. Vertex AI Gemini is the reliability anchor of the platform's LLM chain, the chain the Copy Coach and the ladder suggestions use.++Quicknode. three.ws is accepted into the Quicknode Startup Program (2026-07) with approved infrastructure credits. Quicknode's globally distributed RPC endpoints are a rung in the Solana RPC failover chain behind agent wallets, settlement verification and live Solana market data: the same chain access every mirrored trade, receipt and passport read relies on.++NVIDIA. three.ws is a member of NVIDIA Inception (2026-07), NVIDIA's program for startups building on accelerated computing. NVIDIA-hosted Nemotron models on NIM are rungs in the same LLM failover chain, and every 3D generation lane on the platform runs on NVIDIA hardware.++OpenAI. three.ws is an OpenAI Select Partner in the OpenAI Partner Network. The free three.ws 3D Studio connector gives ChatGPT eleven keyless 3D tools. The same MCP-first approach puts copy-trading tools such as trade_receipt on the three.ws MCP server, which is listed live on the Official MCP Registry.++IBM. three.ws is an IBM Business Partner. Agents on three.ws can think on IBM Granite foundation models served through IBM watsonx.ai, and three.ws also publishes an independent set of developer tools built on IBM's publicly available Granite models.++Amazon Web Services. three.ws is an AWS Partner. The AWS Marketplace integration is built and deployed, and the Marketplace listing is coming.++Alibaba Cloud. three.ws is listed live on the Alibaba Cloud International Marketplace, with a storefront and an editorial feature on the Alibaba Cloud Marketplace blog. Qwen models are first-class lanes in the platform's model router.++HackerNoon. three.ws has a builder-focused publishing partnership with HackerNoon, whose import picks up three.ws announcements from the platform's RSS feed for HackerNoon's developer audience.++## What the system guarantees++Every closed round-trip in a window is part of the computed record, and the leaderboard, profile and attestation all read one function over one ledger.++Credited trading covers coins other than the trader's own launches, which are reported separately and in full.++Copyable leaders have an established record of at least 5 closes over at least 24 hours and 0.1 SOL, and every copy relationship connects independent owners.++Headline numbers are committed daily to Solana and can be re-checked against any RPC node, with age and drift reported in every response.++A receipt is built from evidence recorded before the exit, with every block timed against the entry.++A ghost replay uses the production sizing engine, exact lamports, and a real committed balance, and prints its context sentences with every result.++A drip ladder publishes every trade immediately, releases higher tiers first, caps every delay at 15 minutes, enforces timing in the database, and shows each seat before anyone subscribes.++Performance fees bill each unit of profit once and settle in $THREE on-chain.++## The live numbers++This article quotes no returns, win rates, copier counts or trader scores. They move by the hour, and everything above exists so that you can read them yourself, from the source.++Two platform figures, read on 2026-10-08 from GET /api/three-token/stats: 4,356 registered agents and 15,170 $THREE holders. Price, market cap, volume and liquidity are on the same endpoint, live.## Where to lookEverything above is open source at github.com/nirholas/three.ws.-The surfaces, all live on three.ws:+Live on three.ws:-/leaderboard for ranked traders, each linking to a profile with the Proof tab, the passport and per-trade receipts.+/leaderboard for ranked traders, each linking to a profile with the Proof tab, passport and receipts.-/mirror for the custodial agent mirror and its leaderboard.+/mirror for the agent mirror./ghost-copy for replays against your own budget.@@ -329,16 +426,18 @@ The surfaces, all live on three.ws:/signals for the signal marketplace.-/meta-allocator for the same cautious question answered with a basket instead of a single leader.+/meta-allocator for allocating across a basket of leaders./vaults for copying with real money under segregated custody and hard spend limits.-/three-token for the $THREE tiers that alpha-drip ladders are priced in.+/three-token for $THREE and the holder tiers alpha-drip ladders use.++/dashboard for your subscriptions, intents and, if you lead, your release ladder.-/dashboard for your copy subscriptions, intents and, if you lead, your signal release ladder.+/partners for the full partner map.-The documentation, written for builders: /docs/copy-trading, /docs/trader-passport, /docs/ghost-copy, /docs/alpha-drip, /docs/trade-receipts, /docs/copy-coach and /docs/signals.+For builders: /docs/copy-trading, /docs/trader-passport, /docs/ghost-copy, /docs/alpha-drip, /docs/trade-receipts, /docs/copy-coach and /docs/signals.The coin is $THREE on Solana at FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump.-Nothing here is financial advice. Check the record, not the screenshot.+Nothing here is financial advice.diff --git a/docs/coinmarketcap-article-2026-10-radar-strategy-lab.md b/docs/coinmarketcap-article-2026-10-radar-strategy-lab.mdnew file mode 100644index 000000000..3dcdbd740--- /dev/null+++ b/docs/coinmarketcap-article-2026-10-radar-strategy-lab.md@@ -0,0 +1,387 @@+---+venue: CoinMarketCap Community (Articles Management > Add a new article)+account: three.ws (official)+categories: Solana, AI, Trading+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. Owner directive: positive framing+ only, so the body describes capabilities and design choices and carries no+ limitation sections, cautionary warnings or disparaging contrasts. Opening sections+ are written for newcomers; the technical depth sits in the middle and end. Cover+ art: 640x360 or that proportion, under 10 MB.+accuracy_notes: |+ Live figures ($THREE holders, registered agents) were read from+ https://three.ws/api/three-token/stats on 2026-10-08 and are labelled with that date.+ Coin Radar mechanics (90-second window, 3-second burst and 5-second snipe windows,+ quality formula, smart-money bonuses, risk-flag thresholds, 12-second poll, keyboard+ shortcuts, the pulse strip, designed empty, no-match and error states, the coin page+ and Fork flow, the public API forms) come from docs/radar.md and src/radar.js. Smart+ Money Radar scoring, labels and the 20-second poll come from docs/smart-money.md;+ the firehose volume (about 32,000 mints a day) is quoted from the same doc. Fade+ Radar definitions, the 0.6/0.4 score weights, verdict bands, the time-split+ calibration method and its figures (26,626 labelled coins as of 2026-09-09; clear+ 22,473 at 22.1 percent, caution 3,541 at 15.7 percent, avoid 612 at 1.8 percent), the+ API forms, the coin-read fields and the exported pure functions come from+ docs/fade-radar.md. Those calibration figures are historical base rates of coins+ going on to win, not returns, and are labelled with their measurement date. Today an+ agent consumes the fade read through the public endpoint or the read module, which+ the body states without claiming any sniper-gate wiring.+ Strategy Object schema, bounds, defaults, versioning, fork lineage, the leaderboard+ rule (aggregated from closed positions, Unproven when there are none, ranked by ROI+ with trade counts shown), the assisted scan, and DCA pause and resume come from+ docs/strategy-objects.md, api/_lib/strategy-schema.js and api/strategies.js.+ Strategy Lab behaviour comes from api/pump/[action].js and+ examples/skills/pump-fun-strategy/handlers.js. The Lab backtest is described as a+ check that a strategy behaves as written, the framing docs/strategy-objects.md uses.+ Sniper backtester behaviour (7/30/90/180-day windows, 6,000-launch cap, 30-minute+ cache, confidence tiers at 10 and 30 matches, peak and terminal exit model, slippage+ and impact model, creator priors computed from earlier launches only, the caveats+ field, the insufficient-data verdict) comes from api/sniper/backtest.js and+ api/_lib/strategy-backtest.js. The equipped-strategy cadence (every 2 minutes, 200+ equips and 3 entries per equip per sweep) comes from vercel.json and+ api/cron/strategy-fanout.js. Sniper fleet pipeline, exit priority and the first live+ trade's execution facts come from docs/agent-sniper.md; that trade's ticker and+ return are deliberately left out. Exit Lab knobs and replay mechanics come from+ docs/exit-lab.md. Signal Marketplace ranking, billing and kill behaviour come from+ docs/signals.md. Partner designations and statuses come verbatim from+ docs/partners.md and docs/listings.md: OpenAI Select Partner, IBM Business Partner+ (with the independent-tools distinction from docs/ibm.md), AWS Partner with the+ Marketplace listing described as coming, Google Cloud for Web3 Startups member,+ Alibaba Cloud International Marketplace listing live, NVIDIA Inception member,+ HackerNoon publishing partnership, Quicknode Startup Program accepted. The Official+ MCP Registry listing (including threews-pumpfun) is from docs/listings.md. No+ partner is described as endorsing three.ws. No win rate, return, or profit figure+ for any strategy appears in this article. Every page path was checked against+ data/pages.json on 2026-10-08.+---++# CoinMarketCap article: reading the launch firehose++Paste-ready for the CoinMarketCap form.++## Title (142 characters)++```+Reading the Solana Launch Firehose: How three.ws Coin Radar, Fade Radar and the Strategy Lab Turn the First 90 Seconds Into Rules You Can Test+```++## Meta description (185 characters)++```+A guide for Solana launch traders: a radar that scores every pump.fun launch, a wallet-graph read on every buyer, strategies written as data, and backtests built on real launch history.+```++## Body++---++Every day, tens of thousands of new coins launch on pump.fun, the Solana launchpad where anyone can create a token in seconds. The platform's own documentation puts it at roughly 32,000 new mints a day. Nobody can read all of that by hand, so everyone who trades it uses some kind of filter: a written rule, a group chat, or a feeling formed in the first few seconds of a chart.++This article is about making that filter explicit. On three.ws you can see a score for every new launch, check who is buying it, write your trading idea down as a clear set of rules, test those rules against real launch history, and then let an AI agent run them from its own wallet with safety checks built in.++We start in plain language for anyone new to on-chain trading, then go deeper into how each piece works. Everything here is open source, Solana first, and every page mentioned is live.++$THREE is the platform's coin, at FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump on Solana. As of 2026-10-08 the live stats endpoint reports 15,170 holders and 4,356 registered agents on the platform.++## The short version++Coin Radar shows every new pump.fun launch with a quality score from 0 to 100, based on how people traded it in its first 90 seconds.++Smart Money Radar shows which wallets have a strong track record of picking coins that go on to graduate, and what they are buying right now.++Fade Radar reads the same wallet history from the other side, telling you how much of a coin's buying comes from wallets that have never yet picked a winner.++Strategy Objects let you write a trading idea as a structured set of rules: when to buy, how much, and when to sell.++The Strategy Lab lets you check those rules, test them on real coins, and run them in a no-money simulation before anything goes live.++The sniper backtester replays your rules over up to 180 days of recorded launches and tells you what they would have done, along with how much data stands behind the answer.++AI agents on three.ws can then run your strategy from their own Solana wallet, inside spending limits you set.++## A few words you will see++A bonding curve is the pricing formula a new pump.fun coin trades on before it has a regular market. Once enough people buy, the coin graduates to a regular automated market.++A launch is the moment a new coin is created and starts trading.++Bundling is when several wallets, often funded from the same source, buy a coin at almost the same instant. It can make a launch look busier than it is.++Smart money means wallets with a proven record of buying coins that went on to graduate.++A backtest replays a set of trading rules over past data to see what they would have done.++Simulate mode runs a strategy against the live market without spending anything, so you can watch it work before trusting it with real funds.++## Why the first 90 seconds matter most++The first minute and a half of a pump.fun launch is when the most is revealed about who is really buying. In that window you can see whether buyers arrive spread out over time or in a single coordinated burst, whether they bought identical amounts, whether the creator kept their tokens, and whether wallets with a strong history are among them. That information is on chain, but it moves far too fast to read by eye.++The Coin Intelligence Engine reads it for you. It runs inside the platform's agent sniper worker, holds a live websocket to the pump.fun trade stream, subscribes to every new mint, and watches a fixed 90-second window with the creator's launch buy counted as trade zero. When the window closes, a deterministic scoring function reads what happened, enrichment folds in category classification, funder clustering and a smart-money cross-reference, and the record is written to Postgres. A serverless twin shares the exact same finalise path, so a record is byte-identical however it was produced.++Coin Radar is a read model over that record. It computes nothing itself, and that is a deliberate strength: the number on the board is the same number an agent strategy gates on and the same number the backtester replays.++## Coin Radar: a screener for the first 90 seconds++### The board at a glance++three.ws/radar shows a market pulse strip, a grid or list of scored launches, and a detail drawer. The pulse strip summarises the whole tape: launches observed in the last 24 hours and the last hour, the split between healthy, mixed and risky launches, and the share touched by smart money or flagged.++The toolbar filters by narrative category, minimum quality, smart-money-only and news, and can hide flagged coins. You can sort by newest, quality, smart money, buyers or volume. Keyboard shortcuts make it quick: press / to search by name, ticker or mint, g or l to switch between grid and list, and r to refresh. Every filter serialises into the URL, so any filtered view is a shareable link.++The board polls every 12 seconds and pauses while the tab is hidden, and an "updated N seconds ago" label shows exactly how fresh the view is.++### What gets measured++Signals are measured from the first observed trade, with a 3-second burst window and a 5-second snipe window.++The bundle score (0 to 1) needs at least 4 buys, at least 4 of them inside the burst, and blends burst density with the share of near-identical buy sizes, since coordinated wallets tend to be funded with identical amounts.++The organic score (0 to 1) blends buyer diversity, timing entropy, and the inverses of bundling, snipe ratio and top-holder concentration, then is adjusted for a dev sell, fresh-wallet dominance and funder connectivity.++The snipe ratio is the share of buy volume inside the first 5 seconds. Concentration is reported for the top 1, 5 and 10 wallets. Dev behaviour records whether the creator sold and how much they bought at launch. The fresh-wallet ratio is the share of buyers with at most one prior transaction, and connectivity is the largest cluster of buyers sharing a funder.++### From signals to one number++These roll into a quality score from 0 to 100. It starts from the organic score times 100, subtracts for bundling, top-holder concentration, a dev sell and fresh wallets, adds a small bonus for unique buyers, then adds smart-money bonuses per proven wallet present (8 for the first, 6 for the second, 4 for the third, up to 18 in total), and clamps the result. The board shows 70 and up as Healthy, 40 to 69 as Mixed, and below 40 as High risk. A coin that has not been scored shows as Unscored rather than zero, because a missing measurement and a measured zero are different things, and a signal that was not measured reads "not measured".++### Every flag has a name and a threshold++Alongside the score, every coin carries named flags with exact thresholds, so you always know precisely what triggered them.++bundle_launch at a bundle score of 0.6 or more.++dev_dumped when the creator sold.++single_whale when one wallet holds half or more of net buys.++low_diversity under 5 buyers.++fresh_wallet_swarm when 70 percent or more of buyers are fresh wallets.++sniped at a snipe ratio of 0.85 or more with fewer than 8 buyers.++coordinated_cluster at a connectivity of 0.4 or more.++sell_pressure when at least 3 sells push the buy-to-sell ratio below 1.++### A board that always tells you where you are++Radar's search, category, minimum quality, smart-money and news filters run on the server, so the board decides which empty state to show from your filter state rather than from the shape of the response. With filters active and nothing passing, it says "No coins match these filters", confirms the radar is live and still scoring, and shows every active filter as a removable chip so you can loosen exactly the one you want. With no filters set, an empty feed shows the "Radar is clear" state, which explains the observation window and links to the raw launch feed.++The same care runs through the rest of the page. Loading uses a skeleton grid. Background polls keep the coins already shown in place, so the board stays steady. The pulse strip is its own request with its own retry, so the feed below keeps working independently.++### From a card to a decision++Click any coin to open the drawer: the full signal grid, a top-50 wallet ledger, the smart-money roster, the labelled outcome once one exists, and the Oracle conviction read. Every mainnet coin also has a full page at three.ws/oracle/coin/ plus its mint, rendered in the markets-hub design with a live price chart, the complete launch intelligence read, Oracle conviction, live market intel, agent transactions and a live trade tape.++From there you can add a coin to your Watchlist, open it in Mission Control at three.ws/terminal, or use Fork, which opens a real pump.fun trade panel for that mint right on the page, with a live quote, the safety firewall's verdict, and your own browser wallet as the signer.++### The Radar API++The feed is public, IP rate-limited and needs no account. /api/pump/coin-intel returns the newest launches with the engine's first-90-seconds read, with parameters for network, sort, limit and smart-money-only. Adding stats=1 returns the market pulse aggregate. Adding a mint with wallets=1 returns one coin's full intel plus its top-50 wallet ledger. A few lines of JavaScript are enough to pull the feed and keep only launches with a quality score of 70 or more and no bundle_launch flag.++## Smart Money Radar: the pedigree layer++Coin Radar adds bonuses for proven wallets, and Smart Money Radar is where those wallets come from. three.ws/smart-money is a live, first-party reputation graph of pump.fun wallets, earned entirely from on-chain outcomes rather than a hand-curated list. It polls every 20 seconds and has three tabs: what smart money is buying right now, the top wallets leaderboard, and a personal watchlist of up to 200 mints.++A rollup job judges each coin six hours after launch: a coin that graduated is a win, anything else a dud. For the top 60 buyers of each judged coin, it folds the result into that wallet's record, counting an entry as early when the wallet's first buy landed within 180 seconds of the coin's first trade.++A wallet's score combines its win rate, a bonus when its early entries do better than its average, and a deduction for dumping, all scaled by confidence that reaches full strength at 12 judged coins. Labels follow from the profile: smart_money at a score of 70 or more, or a sustained edge of a 35 percent win rate over 8 or more judged coins (against a platform base rate of around 12 percent); fresh under 4 judged coins; and distinct labels for dumpers, snipers and repeat launchers with no graduations.++Each live coin then gets a buy-weighted pedigree score from its non-creator buyers plus a network bonus of 4 points per proven wallet (capped at 20), and a notable roster of its top 8 wallets, each re-resolved to its live label. This is the same proven-wallet ledger the WHO pillar of the Oracle conviction model draws on.++## Fade Radar: reading the other side of the wallet graph++Smart Money Radar asks which reputable wallets are buying a coin. Fade Radar asks the mirror question: how much of a coin's buy side comes from wallets that have watched many coins resolve and have not yet held a single winner? It answers with a 0 to 100 fade score, a verdict, and the measured odds behind each verdict.++### The definition++A reverse indicator is a wallet the platform's wallet graph has watched buy at least 5 coins with known outcomes, none of which won. A win is a coin that graduated to an automated market or peaked at 3x or better on market cap, taken from the same labelled ground truth the intelligence engine learns from. A wallet under the 5-coin bar is simply new and never appears. Reverse-indicator status is read live from the same wallet reputation graph that powers Smart Money Radar, so both sides are always equally fresh.++### The score and the verdict++Over a coin's observed buyers, excluding the creator:++fade_score = round(100 x (0.6 x buyer share + 0.4 x volume share))++Both shares count because they capture different things: many small wallets are a crowd, one large buy is conviction, and the score reads both. When no buy volume has been recorded yet, the buyer share carries the whole score.++The verdict follows buyer share. Fewer than 5 observed buyers is unknown, since that is too thin to read. No reverse indicators is clear. Some presence under 25 percent of buyers is caution. 25 percent or more is avoid. The creator is excluded because a developer's own supply is already covered by the dev-sold and concentration signals, and would otherwise count once in every coin they launched.++### An out-of-sample calibration++A wallet's record is built from coin outcomes, so Fade Radar measures its bands with a time split. It divides labelled history in half by label time, rebuilds the reverse-indicator cohort from the earlier half only, and measures how often coins labelled in the later half went on to win, band by band. The later coins could not have shaped the cohort that judges them, so the measurement is genuinely out of sample.++The documentation records the result as of 2026-09-09, over 26,626 labelled coins. The clear band, 22,473 coins, went on to win 22.1 percent of the time. Caution, 3,541 coins, 15.7 percent. Avoid, 612 coins, 1.8 percent. These are historical base rates of a coin graduating or reaching 3x, measured on the held-out half. The page recomputes them from live history at most every 12 hours, so three.ws/fade always shows a dated measurement.++### How a fade read is used++On a bonding curve, the way to act on a fade read is simply to pass on the coin. Fade Radar is a read-only signal: the page never emits a trade and never signs anything, and every wallet on the fade board links straight to its full track record on Smart Money Radar.++### The Fade API and agents++The public endpoint at /api/pump/fade serves four reads: the live coin board (coins from the last few hours with reverse-indicator money in them), a per-coin read with the reverse-indicator wallets inside it, the reverse-indicator wallet board sorted by record, and the calibration itself. A coin read returns the score, the verdict, buyer counts, the buyer and volume shares, a confidence, the notable wallets with their judged buys, and a one-sentence plain-language summary. A coin the engine has not observed resolves cleanly with computed set to false, so a detail page can always render.++An agent can call the read module directly and pass on any coin with an avoid verdict in a few lines of code. The scoring, verdict and summary functions are also exported as pure functions, so a caller that already has a coin's buy side in hand can score it with no database round trip.++## Strategy Objects: a trading idea as data++A Strategy Object is a structured, validated rule set with a real owner and a real track record. Every config is normalised and validated before it is saved, so a stored strategy always carries well-formed, bounded values into the runtime.++### The four sections++Entry: a new-launch trigger, a maximum age, an optional market-cap band, minimum liquidity, a socials requirement, creator-history gates (how many coins the creator launched before, and how many of them graduated), and a SOL-quote requirement.++Sizing: SOL per trade and maximum slippage.++Exits: take-profit, a mandatory stop-loss, an optional trailing stop, and a maximum hold. Every strategy carries a stop-loss and at least one upside exit.++Risk: maximum concurrent positions and a cooldown.++### Bounds and defaults++Every field has hard bounds: 0.0001 to 100 SOL per trade, a stop-loss between 1 and 99 percent, 1 to 50 concurrent positions, and a maximum age of seven days. The defaults are 0.1 SOL per trade, 500 basis points of slippage, a 100 percent take-profit, a 40 percent stop-loss and 3 open positions.++Two pure functions decide entry and exit, and the same two run in the live runtime and in the assisted scan preview, so a rule means exactly the same thing everywhere it runs. The assisted scan lets an owner preview which real launches a strategy would match right now. It is owner-scoped and rate-limited per IP and per owner, and when the live launch feed is unreachable it says so explicitly rather than returning an empty scan, so "nothing matched" always means nothing matched.++### Versioning, forking and publishing++The library lives at three.ws/strategies, with the marketplace of published strategies, the leaderboard and your own library on one page. The full-page builder keeps its state in the URL, so it survives a reload and the back button.++Editing a config bumps its version, and agents that already equipped it keep their snapshot until re-equipped, so an edit never silently changes what a running agent does.++A published strategy can be forked by anyone signed in. A fork copies the rules only, starts at version 1 under the forker's ownership, records the source strategy and version, credits the author, and counts toward the original's fork total. The forker runs the rules under their own agent's spend policy, and no wallet access ever moves. Deleting a strategy deactivates its equips, and open positions stay with their owner to manage.++### The leaderboard++The leaderboard ranks published strategies by real return, aggregated from closed on-chain positions across every agent that equipped them. A strategy with no closed positions is labelled Unproven and is never given a synthetic curve. Each entry shows its closed trade count, wins and losses alongside its return, so a reader can weigh every ranking by the sample behind it.++### Scheduled buys++For recurring buys, three.ws also supports DCA strategies: validated schedules with an agent, a signed delegation, tokens in and out, an amount per execution, a daily or weekly period, and slippage capped on the server. A schedule can be paused and resumed. On resume, the next execution is scheduled a full period out, so periods missed while paused never fire as a burst, and every strategy stays visible in the agent's list with its full history whatever its status.++## The Strategy Lab: validate, test, run++three.ws/strategy-lab is the workbench. It uses a small declarative spec with four parts: a scan (new tokens, trending tokens, or a list of mints), filters, an entry, and exit rules. Filters and exits are simple predicates, such as "top holder share under 20", "creator rug count equals zero" or "sell half when the position is up 50 percent", read from a view of the coin's holders, creator, bonding curve, trades and, once open, the position. One compiled evaluator powers validation, backtest and live runs, so all three always agree.++### Validate++Validate needs no sign-in and returns field-level issues, so you can fix a spec line by line. Backtest and run repeat the same check first, so every run starts from a clean spec.++### The Lab backtest: a fast check that a strategy behaves as written++The Lab backtest (sign-in required) is the quickest way to confirm your spec does what you meant on real coins. For each candidate mint it fetches the token's details, holders, bonding curve, creator profile and up to 200 trades from real recorded on-chain history. Candidates come from your own mint list or from a live scan of new or trending launches, read from pump.fun's public feed and the platform's own launch recorder, so no external indexer is needed. It evaluates the entry gate, enters at the first trade in that history, and walks forward through the real trades until an exit rule fires.++It reports spend, realized PnL, ROI, trade count, win rate, maximum drawdown, every individual trade and the mints used. It never synthesises a launch or invents a price path. For a statistical read over a large universe of launches, the sniper backtester below is the right tool, and the two work well together.++### Run: simulate first++A run lasts 5 to 600 seconds and streams entries, exits and logs live over Server-Sent Events. Simulate mode needs no wallet and spends nothing, so you can watch your strategy react to the live market risk free. Live mode needs sign-in, an accepted real-funds agreement on mainnet, and an agent you own with a Solana wallet, and every buy passes the same spend-policy check the rest of the platform uses. Close-all exits open positions on demand.++## The sniper backtester: real launch history, at scale++The second backtester, at POST /api/sniper/backtest, is built for the statistical question: across hundreds or thousands of real launches, what would these rules have done? It also lives inside an agent's Snipe tab in the agent wallet, where you can describe a strategy in plain English, have it compiled into a validated config clamped to that agent's spend guards, and backtest it before anything is armed.++### What it replays++It replays every launch the intelligence engine observed, with its signals, joined to the coin's labelled outcome (graduated, pumped, flat or rugged), its peak multiple and its last market cap. Only launches with a real label are used. You pick a 7, 30, 90 or 180 day window, and a run considers up to 6,000 labelled launches, reporting the universe size alongside the sample.++Entries are decided by the exact scorer the live sniper runs, and exits by the exact exit function it runs. The backtester feeds production code rather than reimplementing it, so a rule means the same thing in a backtest as it does live.++### How it models a trade++The capture holds two real price points per launch: the peak and the final value. As price climbs to the peak, take-profit is evaluated; on the way down, stop-loss and then trailing stop are evaluated at the final price, and a position with no exit is valued at the final price.++Costs are modelled too. Entry cost is inflated by slippage (500 basis points by default) and by a price-impact estimate based on the coin's recorded early buy volume relative to your trade size, and exits are reduced by slippage. Launches over your maximum price impact are skipped, just as they would be live. With no trade size set, a notional 0.1 SOL is assumed and the response says so.++Creator history is computed carefully: prior launch and graduation counts come only from coins that creator launched before the one being scored, so each decision sees only what was knowable at the time. Every response carries a caveats field describing the run's assumptions in plain words.++### What it returns++You get win rate, expected value per trade, the median, the 10th and 90th percentile, the best and worst trade, net PnL, maximum drawdown, an exit-reason breakdown, the outcome mix of the coins your rules entered, sample hits and misses, and how many launches were skipped and why.++Every result carries a confidence label based on its sample: low under 10 matching launches, medium under 30, and high from 30 up. When nothing matches, the response is an explicit insufficient-data verdict that says whether the history is empty or the filters are too strict, the same idea as Radar's no-match state applied to backtesting. Results are cached for 30 minutes by a hash of the trade-determining fields and linked to the agent, so its profile can later compare projected results with realized ones.++Used well, a backtest answers practical questions quickly: how your filter's entries split across graduated, pumped, flat and rugged outcomes, which exit rule closes most of your positions, how deep a drawdown your sizing would have weathered, and whether your rules are selective enough to pass anything at all.++## Exit Lab: tuning the exits on real trades++three.ws/exit-lab answers a complementary question: were the exits on real fleet trades the right ones? It takes positions the agent fleet genuinely opened and closed on chain and re-runs each one through the exact laddered exit code the live worker runs, with the rules changed to whatever you choose.++The knobs are the hard stop-loss (35 percent by default), the trailing stop (25 percent, armed only once a position has been green), a take-profit ceiling (off by default), the take-initials multiple at which the stake comes back off the table (2x), and the moon-bag floor that always keeps riding on a profitable exit (15 percent). Every entry price, high-water mark and final quote is a recorded number from a real position, the corpus excludes anything simulated, and the replay runs instantly in your browser against the same kernel the server uses, so every slider move updates on the spot. The underlying data is public at /api/sniper/exit-lab, and the replay kernel is a pure module anyone can import.++## Where agents come in++### An agent running a strategy++Equipping a strategy attaches it to an agent you own. A scheduled sweep runs every two minutes: for each active equip, up to 200 per network, it checks real pump.fun launches against the entry rules, takes at most 3 new entries per equip per sweep, and re-quotes open positions on chain to decide exits. That cadence suits rules that judge launches over minutes; the first seconds of a launch are the sniper fleet's job.++Every strategy trade passes the same guards as any agent trade: the owner's strategy kill switch, the per-equip active flag, the agent's per-trade cap, its daily budget and USD ceiling, the price-impact breaker, the rug and honeypot firewall, and SOL fee headroom. The strategy's caps sit on top of all of these, so a strategy only ever adds constraints. A retried entry cannot double-spend, and every trade lands in the custody ledger tagged with its strategy.++### The sniper fleet++The first seconds of a launch belong to the agent sniper, a long-lived worker that fires on the new-mint feed, a creator's first fee claim, intel and radar signals, a coin's migration, or its first Oracle conviction crossing. A coin must pass the entry scorer (the same one the backtester replays), a fleet-wide market-cap band a strategy can narrow but never widen, a filter excluding pump.fun Mayhem-mode tokens, and a firewall that runs a real simulated buy and sell on chain to prove the coin can be sold. Only then does the executor sign from the agent's custodial wallet. Exits run in strict priority: stop-loss, signal flip, trailing stop, take-profit, timeout.++Every buy writes a hash-chained entry to the agent's decision ledger with its inputs, rationale, a falsifiable prediction and a confidence, and the chain head is anchored on Solana so the history can be verified independently. The fleet is public at three.ws/sniper/experiments, refreshed every 30 seconds, with each arm's wallet, live balance and full reasoning ledger.++The fleet's first live trade, on 2026-07-19, shows the gates at work: its strategy scanned launches for roughly nine days before one coin cleared every gate, the firewall's round trip returned a score of 100, and the transaction landed in 1,709 milliseconds with 0.05 percent price impact.++### How the pieces connect++Radar's quality score, bundle score, top-holder concentration, dev-sold flag and category are exactly the fields a sniper strategy gates on and the backtester replays. "Minimum quality 60, maximum bundle 0.5, avoid a dev dump" means the same thing on the board, in the backtest and in the live worker. Fade Radar plugs in through its public endpoint or read module, so an agent can add an avoid-verdict check to its own logic in a few lines.++### Alpha Copilot and the Signal Marketplace++three.ws/alpha-copilot lets an agent read a live launch aloud, grounded in fetched liquidity, holder and smart-money data, with any figure that does not match the fetched data replaced before it is spoken.++three.ws/signals is a marketplace of live trading feeds published by verified traders, where every signal is minted from the publisher's real on-chain fills. Your agent subscribes, pays per signal or per epoch in USDC over x402, and mirrors each call through the same firewall and spend policy it always runs under. Feeds are ranked by proven realized edge, regressed toward neutral until a feed has 10 closed signals and flagged "Building track record" until then. Closed signals are public in full with their Solscan links, subscribing in simulate mode mirrors without paying or trading, and a kill switch halts all further payment and trading the instant it is set.++## A workflow for a Solana launch trader++Watch three.ws/radar with no filters until you know what a normal hour looks like. Add filters one at a time, and use the filter chips to see exactly what each one does.++Check three.ws/smart-money and three.ws/fade on anything that catches your eye. Proven buyers and a clear fade verdict are two quick reads on who is in a coin.++Write your rule as a Strategy Object with a stop-loss you are comfortable with. Validate it in the Lab and run a Lab backtest on a handful of coins to confirm the spec behaves as written.++Run a sniper backtest over 30 or 90 days. Read the sample size, the confidence label and the caveats alongside the metrics. If it reports insufficient data, loosen a filter or widen the window.++Run the strategy in simulate mode and watch the live stream. When you go live, start small, set a daily budget, and follow every decision in the ledger.++Tune your exits in Exit Lab, and publish your strategy to the library so others can fork it with credit to you.++## Our partners++three.ws is built alongside a set of cloud, AI, infrastructure and media programmes, listed in full at three.ws/partners. Each designation below is the programme's own, and three.ws remains an independent company in all of them. Several connect directly to the tools in this article.++Google Cloud. three.ws is a member of Google Cloud for Web3 Startups, and production runs on Google Cloud. The API behind Radar, Fade Radar, Smart Money Radar, the strategy library and both backtesters runs on Cloud Run, the agent sniper worker that hosts the Coin Intelligence Engine is its own Cloud Run service, and the scheduled jobs (the two-minute strategy sweep, the smart-money rollup) run on Cloud Scheduler.++Quicknode. three.ws was accepted into the Quicknode Startup Program in 2026-07 with approved infrastructure credits. Server-side Solana calls across the platform run through an RPC failover chain, and Quicknode is a rung in that chain, adding capacity and redundancy behind agent wallets, x402 settlement verification and live market data, the kind of calls that on-chain re-quotes and firewall simulations rely on.++NVIDIA. three.ws is a member of NVIDIA Inception, NVIDIA's programme for startups building on accelerated computing. NVIDIA-hosted models run a large share of the platform's AI, including rungs of the LLM failover chain behind the agents described here, and every 3D generation lane on three.ws runs on NVIDIA hardware.++OpenAI. three.ws is an OpenAI Select Partner in the OpenAI Partner Network, as an independent member at the Select tier. The free three.ws 3D Studio connector gives ChatGPT eleven keyless 3D tools, and the main three.ws MCP server is a public OAuth 2.1 server that any MCP client can connect to.++IBM. three.ws is an IBM Business Partner. Alongside that, the platform publishes an independent set of developer tools built on IBM's openly available Granite models, including Granite TimeSeries forecasting, rendered as a walk-around 3D forecast of a live token's price history inside three.ws/play.++Amazon Web Services. three.ws is an AWS Partner. The AWS Marketplace SaaS integration is built and deployed, and the Marketplace listing is coming. Once it is live, subscribing will link an AWS account and issue an x402 access key, the same payment rail the Signal Marketplace uses.++Alibaba Cloud. The three.ws listing on the Alibaba Cloud International Marketplace is live, and Alibaba Cloud Marketplace published an editorial feature introducing the platform. Qwen models are first-class lanes in the three.ws model router.++HackerNoon. three.ws has a builder-focused publishing partnership with HackerNoon for feature articles, tutorials and developer guides, with posts imported from the three.ws announcements feed.++Beyond the programmes, the three.ws MCP servers, including a dedicated pump.fun server, are published on the Official MCP Registry, and pump.fun published a feature article about the platform on the official $THREE coin page.++## Where to look++Everything in this article is open source at github.com/nirholas/three.ws.++Live surfaces: three.ws/radar, three.ws/smart-money, three.ws/fade, three.ws/strategies, three.ws/strategy-lab, three.ws/exit-lab, three.ws/sniper/experiments, three.ws/alpha-copilot, three.ws/signals, three.ws/terminal and three.ws/partners.++Live $THREE figures are at https://three.ws/api/three-token/stats.++Nothing here is financial advice.diff --git a/docs/coinmarketcap-article-2026-10-sniper-oracle.md b/docs/coinmarketcap-article-2026-10-sniper-oracle.mdnew file mode 100644index 000000000..a191a276d--- /dev/null+++ b/docs/coinmarketcap-article-2026-10-sniper-oracle.md@@ -0,0 +1,426 @@+---+venue: CoinMarketCap Community (Articles Management > Add a new article)+account: three.ws (official)+categories: Solana, AI, Trading+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. No performance, profit, return or+ win-rate claim is made for any trading strategy or arm anywhere in the body; the one+ historical trade mentioned is described by its execution facts only, with its return+ deliberately left out. Owner directive: positive framing only, so the body describes+ capabilities, design choices and what is rolling out, and carries no incident+ narratives or limitation sections. Opening sections are written for newcomers; the+ technical depth sits in the middle and end. Cover art: 640x360 or that proportion,+ under 10 MB.+accuracy_notes: |+ Live figures (4,356 registered agents, 15,170 holders, the 10 percent revenue-share+ pool) were read from https://three.ws/api/three-token/stats on 2026-10-08 and are+ labelled with that date. The sniper pipeline, triggers, guardrails, sizing floor,+ exit order, ladder and house-money behaviour, firewall behaviour, custody audit,+ solvency model, alerts, the public experiments page, the Oracle feedback bridges and+ the first live trade's execution facts (2026-07-19, 0.05 SOL, 0.05 percent impact,+ protected route landing in 1,709 ms, firewall score 100, roughly nine days of+ scanning, the arming config) come from docs/agent-sniper.md and+ workers/agent-sniper/README.md; that trade's return is deliberately omitted. The+ sniper runs as the agent-sniper Cloud Run service built by+ workers/agent-sniper/cloudbuild.yaml. Earned-autonomy tiers, unlocks, knowledge packs+ and the untouchable safety floor come from docs/sniper-autonomy.md. The optimizer and+ evolution loops are described as shadow or dry-run by default, which matches+ docs/agent-sniper.md and the 2026-10-01 switch to shadow recorded in+ docs/ops/sniper-fleet-review-2026-10-01.md; the body never claims they are applying+ changes. Spend-policy fields come from api/_lib/agent-trade-guards.js and the bridge in+ workers/agent-sniper/executor.js. Oracle model facts (three heads, base rates,+ held-out AUCs on 74,211 launches, the 11.4 percent rug rate and its stability, the+ 27.958993 SOL empty-curve floor, at_floor duds, n/(n+200) shrinkage, the 200-row+ feature rule, the promotion gate thresholds, the six-hour refit, the 2-minute model+ TTL, the 351-sample smart-money bucket, the 45-point serial-rugger ceiling, the npm+ package API) come from docs/oracle-model.md, docs/oracle.md and+ packages/oracle-model/README.md. The Oracle worker loops, arming gates, size-scaling+ formula, backtest and receipts surfaces, Telegram feed, coin pages and x402 feeds come+ from docs/oracle.md. The four Oracle MCP tools (oracle_top_plays, oracle_coin,+ oracle_arm_watch, oracle_watch_status) are in api/_mcp/tools/oracle.js. The vitals+ model, CLI output, HTTP gating and package facts come from docs/agent-vitals.md and+ packages/agent-vitals/README.md; the declared loops and their freshness windows from+ api/_lib/sniper-loops-health.js; stall diagnoses from api/_lib/sniper-stall.js.+ Rolling-out items (house-money ladder handling, token-account close on full exit, the+ oracle_crossing graduated and dead-curve checks) are committed per+ docs/ops/sniper-fleet-review-2026-10-01.md but the live agent-sniper image dates from+ 2026-09-29, so the body describes them only as rolling out with the next worker+ release and describes the crossing trigger's live checks as youth and score+ freshness. Dedicated Oracle and trading MCP servers are described as on the roadmap per+ docs/oracle-trading-mcp-plan.md. Partner designations and statuses come verbatim from+ docs/partners.md and docs/listings.md: OpenAI Select Partner, IBM Business Partner+ (with the independent-tools distinction from docs/ibm.md), AWS Partner with the+ Marketplace listing described as coming, Google Cloud for Web3 Startups member,+ Alibaba Cloud International Marketplace listing live, NVIDIA Inception member,+ HackerNoon publishing partnership, Quicknode Startup Program accepted. The LLM chain+ rungs (NVIDIA Nemotron, Qwen) come from api/_lib/llm.js. No partner is described as+ endorsing three.ws.+---++# CoinMarketCap article: inside the three.ws sniper fleet and Oracle model++Paste-ready for the CoinMarketCap form.++## Title (173 characters)++```+Inside the three.ws Solana Sniper Fleet: AI Agents That Trade From Their Own Wallets, an Oracle Model Published With Its Weights, and Health Checks That Confirm They Can Act+```++## Meta description (190 characters)++```+How three.ws agents trade Solana launches from their own wallets, with an on-chain safety firewall, a hash-chained decision ledger, an Oracle model anyone can run, and can-act health checks.+```++## Body++---++Imagine giving your AI agent its own wallet and a simple set of instructions: watch new coins as they launch, buy the ones that match my rules, sell when my exit conditions are met, and write down every decision so I can check your reasoning later. That is what the sniper fleet on three.ws does, every day, on Solana.++This article is a friendly tour of how it works. We start in plain language for anyone new to on-chain trading, then go deeper: how each trade passes a chain of safety checks, how the Oracle conviction model that guides many of the agents is built and published so anyone can download and test it, and how we check whether each agent is genuinely ready to act right now. Everything described here is open source, and every page mentioned is live.++$THREE is the platform's coin, at FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump on Solana.++## The short version++If you only read one section, read this one.++Every agent on three.ws has its own Solana wallet. The owner decides whether that wallet may trade, and on what terms.++The sniper is the part of three.ws that lets an agent trade new coins on its own. It watches launches the moment they happen and judges each one against rules the owner wrote.++Before an agent buys anything, the system rehearses the trade on chain: it simulates buying the coin and then selling it back, to prove the coin can actually be sold.++Every decision is written to a public ledger, chained together with cryptographic hashes so the history cannot be quietly rewritten, and periodically anchored on Solana itself.++The Oracle is a scoring model that rates each new launch from 0 to 100. Its weights are published as a free package, so anyone can run it on their own computer and check our numbers.++A health system asks a simple question about every agent: can it act right now? If not, it names the one thing to fix.++## A few words you will see++pump.fun is a Solana launchpad where anyone can create a coin in seconds. Tens of thousands of coins launch there every day.++A bonding curve is the pricing formula a new pump.fun coin trades on before it has a regular market. When enough people buy, the coin graduates (migrates) to a regular automated market.++Sniping means buying a coin very early, often within seconds or minutes of launch.++An arm is one strategy in the fleet: one agent, one wallet, one set of rules.++The Oracle score is a number from 0 to 100 describing how strong the on-chain evidence for a launch looks, sorted into named tiers.++The ledger is the public, tamper-evident record of every decision an agent makes.++x402 is an open payment standard that lets software pay for an API call with a small stablecoin payment, with no account or subscription.++## What the sniper fleet is++### One wallet per agent++Every three.ws agent has its own custodial Solana wallet. The private key is stored encrypted at rest in an AES-256-GCM secret box and is only ever decrypted inside the one file of the worker that signs transactions. The Agent Sniper lets that wallet trade on its own: it watches pump.fun launches as they happen, judges each new coin against a strategy the owner armed, runs an on-chain safety simulation before committing a lamport, buys from the agent's own wallet, manages the position to an exit, and writes every decision to a hash-chained ledger anyone can audit.++### Many strategies, side by side++The fleet is several of these strategies, called arms, running side by side against the same launches, so deliberately different rule sets can be compared on a public scoreboard. Some use hard rules, some are gated on Oracle conviction, some hand the entry decision to a language model, and one rides the window right after a coin migrates off its bonding curve. The worker runs on Google Cloud as its own Cloud Run service, built by Cloud Build.++## How a snipe happens, gate by gate++A snipe is not one decision. It is a chain of gates, and a coin has to clear every one before a single lamport moves.++### Triggers: watching the launch feed++The worker is a long-lived process holding the pump.fun new-mint feed open, deliberately a continuously running service rather than a scheduled job, because launches are measured in seconds.++Alongside the new-mint trigger sit several others: a first-claim trigger (the first time a creator claims their fees), an intel-confirmed trigger from the Coin Intelligence Engine that reads each coin's first ninety seconds, alpha and radar variants, a graduation-ride trigger that buys at migration and sells into pump.fun's five-minute post-migration buyback window, and the oracle-crossing trigger covered below.++### Entry scoring and the safety band++Entry scoring is a pure function with no network or database access, which makes it fast, deterministic and easy to test. The coin must be quoted in SOL, sit inside the strategy's market-cap band, pass creator-history checks, and carry socials (a website, an X account or a Telegram) if the strategy asks for them. Every skip is recorded with a reason, so an owner sees why a coin was passed over, not only which coins were bought.++Above every strategy sits a fleet-wide market-cap floor and ceiling that a strategy can narrow but never widen. A coin whose market cap cannot be confirmed is skipped: the sniper only buys what it can price. pump.fun's Mayhem-mode tokens are excluded on every path by owner rule. That flag is not carried in the launch feed, so the worker reads it straight from the coin's on-chain bonding curve with one cached RPC read per mint, and if the curve cannot be read, the coin is skipped.++### The firewall proves the exit before the entry++Before broadcasting a buy, the executor runs a real simulated buy followed by a real simulated sell on chain. This round trip is the heart of the safety stack: it proves, before any money moves, that the coin can be sold again.++The classification is leg-aware. A revert on the sell leg is the honeypot shape (you can get in but not out), and that is a hard block. A revert on the buy leg usually means the price moved past the quoted slippage or the payer could not fund the probe, which says nothing about sellability, so it is recorded as a warning. A separate authority audit checks the coin's freeze and mint authorities.++The probe is sized to the wallet doing the buying, because sellability is a property of the coin, not of the probe size. A wallet that cannot fund even the minimum probe records the safety as unproven, and each strategy chooses its firewall level: block aborts on a block verdict or on unproven safety, and warn proceeds with a lowered confidence score.++### Execution and sizing++One file in the worker signs. The key is decrypted, the versioned transaction is signed and broadcast with the strategy's slippage and priority fee, and an idempotency lock guarantees one buy per mint per strategy. Before that moment, the executor walks its hard guardrails: a global kill switch, a per-agent kill switch, the daily budget, the open-position cap, a stop-loss that the database refuses to let be set to zero, a price-impact breaker checked against a fresh quote, and a platform-wide limit on buys per minute.++Sizing adapts to the wallet. A buy that would overrun the day's remaining budget is clamped to what is left, and a wallet holding less than its configured trade size trades at what it can afford after leaving headroom for fees. There is an operational floor of 0.012 SOL: below that, the wallet could not fund the safety simulation, so the arm waits for funding instead of looping on simulations it cannot pay for.++### Spend policy and session keys++The sniper also answers to the same per-agent spend policy that governs withdrawals, x402 payments and discretionary trades across three.ws: a rolling 24-hour USD ceiling, a per-transaction ceiling, a per-counterparty ceiling and an optional withdrawal allowlist. These are opt-in, and once set they apply on every path.++Owners can layer natural-language rules on top, which a pure evaluator enforces and which can only ever tighten the numbers, never loosen them. Scoped session keys let an owner grant narrow authority, for example permission to spend only on one strategy against one mint. Inside the sniper, the strategy's own lamport caps sit underneath all of this as the innermost backstop, so the policy is layered from the outside in.++### Exits, the ladder and house money++A sweep re-quotes every open position against its bonding curve, or against the automated market after graduation, and updates each position's high-water mark. A pure function then decides exits in strict order: stop-loss first, then signal-flip, then trailing stop, then take-profit, then timeout. It has no clock and no I/O, so a backtest and the live worker agree on exactly when a position closes.++The trailing stop arms only once a position has been above breakeven, so a position that has not yet been green is governed by the stop-loss alone. That rule was set by measuring the fleet's first 90 trades.++The laddered exit is the most distinctive policy in the fleet. At a configured multiple (2x by default in the research policy) it sells enough to recover the original stake, and lets the rest ride as a moon bag on the trailing stop, with a configurable moon-bag floor that always keeps a share of the position riding on a profitable exit. Every field of the strategy, from the ladder multiple to the moon-bag floor, is settable through the strategy API, and an explicit null returns a clearable field to its default behaviour.++### The decision ledger and custody audit++Every trade appends an entry to the agent's decision ledger: the trigger, the firewall verdict and score, the price impact, the size, a plain-language rationale, a falsifiable prediction and a mechanically computed confidence. Entries are hash-chained, each carrying the hash of the one before, so the history cannot be silently rewritten.++A reconciliation job closes each prediction against its real outcome, then anchors the chain head on Solana through an SPL Memo, so anyone can verify the history independently through a public verify endpoint for each agent. Custody is audited too: key recovery, the spend and the exit each write a custody event, and every wallet's balance is committed into the platform's custody attestation Merkle tree each epoch.++### The first live trade++The fleet's first live trade, on 2026-07-19, illustrates the pipeline working end to end on mainnet. The platform's own agent, named three, bought a brand-new launch on a new-mint trigger with 0.05 SOL. The firewall's round trip returned allow with a score of 100, the price impact was 0.05 percent against a 10 percent ceiling, and the transaction landed on a protected route in 1,709 milliseconds. Its strategy (0.05 SOL per trade, a 0.2 SOL daily budget, a $5k to $25k band, socials required, firewall on block) had scanned launches for roughly nine days before one coin cleared every gate, exactly the selectivity the gate chain is built for. Both signatures and the ledger entry are public.++## Who decides: rules, the Oracle and models++### Rules arms++Rules arms run the gate chain above at different levels of strictness: different bands, different creator-history requirements, different socials and dev-dump settings, different exits. They are the steady baseline the rest of the fleet is compared against.++### Oracle arms, paying for intelligence over x402++Oracle arms require a minimum Oracle conviction score before buying, and the bar moves per coin. The sniper pays the platform's own intelligence endpoint one cent of USDC per call over x402 for a live market read on each coin it is watching. A bearish read raises that coin's bar and a bullish one lowers it. Macro signals from the platform's autonomous x402 loop widen or tighten the bar too, based on overall SOL and pump.fun market sentiment. Both adjustments are clamped.++In other words, the trading engine is a paying customer of the intelligence engine. That is the agent-to-agent economy running in production: one piece of software buying a signal from another piece of software with a real stablecoin payment, settled on chain.++### The oracle-crossing trigger++Most triggers judge a coin at launch, when the Oracle has only just started to collect evidence. The oracle-crossing trigger waits for the evidence instead. A watcher polls the Oracle's conviction table and buys a coin the first time its score crosses the strategy's bar (50 by default), provided the coin is young (90 minutes by default) and the score is fresh. Each strategy gets one attempt per coin, every candidate passes through the same buy chokepoint as every other trigger (Mayhem gate, firewall round trip, budgets, market-cap clamps), and an explicit x402 rug-pull check sits on top.++### Model arms and the judgment ledger++Model arms ask a language model, reached through the platform's LLM failover chain, for a structured decision: buy or not, a confidence and a thesis in plain words. The arm acts only above a confidence bar (0.6 by default). Every verdict, buys and skips alike, is later scored against what the coin actually did, so a model's judgment can be measured before its trades even close, and that judgment ledger is public. The essential rails (Mayhem exclusion, the firewall, budgets, concurrency, fee headroom, spend policy) apply to model arms exactly as to rules arms, at the one chokepoint every buy passes through.++### The risk officer++A second model, an adversarial risk officer told to assume each proposed trade is a bad one and argue why, ships in shadow mode. It records what it would have vetoed and changes nothing until an owner arms it, so its judgment builds a visible track record first.++## Earned autonomy: room the arms earn++Two loops can tune the fleet without a human in the seat. The optimizer proposes bounded changes to each arm's own knobs (take-profit, stops, hold time, entry thresholds, trade size) from its realized record. The evolution loop scores arms against the ground-truth base rate with Wilson confidence bounds and moves the fleet's fixed daily budget toward stronger arms. The optimizer never touches budget, and evolution never touches a per-arm knob.++Both run in shadow by default: they record what they would change and mutate nothing until an owner opts in, so their calls build a visible record first, and every applied change is logged to the agent's Reasoning Ledger.++### The four tiers++How much room an arm gets is earned from its own realized record, recomputed from scratch on every run. Probation narrows the bounds, halves the step size and caps trade size at 0.05 SOL. Standard is the default for arms with too few trades to judge. Trusted, earned with a positive net result and an average edge of at least half a percent over 12 or more real trades, widens the bounds, multiplies the step by 1.75 and unlocks five more fields: the model's confidence bar, both edges of the market-cap band (widened outward only) and the two take-initials ladder settings. Autonomous, earned with an average edge of at least 5 percent over 40 or more real trades, opens the widest bounds, a 2.5x step and every tunable field.++The tier is decided on realized net result plus average per-trade edge rather than win rate, so the room goes to the arm whose record is strongest in actual lamports. Because it is recomputed every run, the room is rented rather than owned.++### More knowledge for proven arms++Tiers also decide how much a model arm is told before it decides. At base depth the judge receives the launch brief and a market-realness read. The informed depth adds the ground-truth base rate, the learned signal weights retrained every 15 minutes and the arm's own record. The full depth adds the conditional win-rate table per signal bucket and the model's own calibration. Every line is read from real database rows.++### What no tier can touch++Earned autonomy widens the space an arm may search. It never removes the floor under it. At every tier the firewall round trip, Mayhem exclusion, price-impact and slippage caps, fee headroom, the daily loss cap, the open-position cap, the fleet budget ceiling and the kill switch stay out of reach, enforced at the buy chokepoint. A hard stop-loss survives every tier: its range can widen to 65 percent but it can never be unset. A unit test asserts that no safety field appears in any tier's writable set.++Models and loops propose; the deterministic pipeline disposes.++### The Oracle and the fleet learn from each other++Three bridges connect the Oracle to the fleet. Realized results train the Oracle: each traded coin's real outcome is preferred over the chart label wherever it exists. The optimizer uses the Oracle: it buckets each arm's realized results by the conviction the coin had at entry and tunes the arm's minimum Oracle score toward the band where it performs. And calibration measures, per conviction band, how realized results compare with the band's claim, writing a bounded correction factor (between 0.7 and 1.3, held at 1.0 until a band has enough real trades) published at /api/oracle/calibration and applied through entry thresholds rather than onto the score itself.++The direction of every bridge is the same: real, realized money is the ground truth.++## The Oracle model, published with its weights++The Oracle watches every pump.fun launch for its first ninety seconds and scores it from 0 to 100. Its defining feature is openness: the weights, the holdout results and every refit decision are public, and the model can be downloaded and run by anyone.++### What the score claims++The score is a ranking line anchored to fixed probabilities, not a percentage. A score of 86 claims a 45 percent chance, not 86. The tiers are anchored like this: Prime (86 and up) claims at least 45 percent, Strong (72 and up) at least 25 percent, Lean (56 and up) at least 12 percent, Watch (34 and up) at least 5 percent, and below that is Avoid. Only Prime and Strong are act signals, which keeps the engine selective. On the bootstrap model's holdout, every populated tier observed at or above the probability it claims, and the live model card at /api/oracle/model?view=card republishes that table on every refit.++### Three questions and give-back risk++The model fits three questions, called heads, over one shared design matrix. Win: did the coin run, and is a first-sight holder still up? (base rate 2.94 percent). Rug: is that holder down more than half? (11.36 percent). Moon: did it run at all, by graduating or peaking at 3x? (9.51 percent). On 74,211 held-out launches the model had never seen, the published AUC (a ranking-quality measure where 0.5 is a coin flip and 1.0 is perfect) is 0.840 for win, 0.918 for rug and 0.892 for moon.++The score anchors on win, a coin that runs and holds. Three heads also make a uniquely useful number possible, give-back risk: one minus P(win) divided by P(moon). Given that a coin like this runs, how often does it hand the run back? It is published on every verdict and indexed, so the feed can be sorted by it.++### Labels that measure the coin++A model is only as good as the outcomes it learns from, so the Oracle's labels are built to measure the coin itself. An empty pump.fun bonding curve is worth a fixed amount in SOL: 30 virtual SOL against 1,073,000,191 virtual tokens over a one-billion supply works out to 27.958993 SOL. A rule written in dollars would move with the price of SOL, so the labels use two ratios from the same market-cap reading, which makes SOL's price cancel out.++Retained value is the last market cap divided by the all-time high. The hold multiple is the all-time-high multiple times retained value: what a first-sight holder would have. Moon is graduated or a 3x peak, rug is not graduated with a hold multiple of 0.5 or less, and win is a moon with a hold multiple of at least 1. Both ratios backfill exactly from stored columns, so the whole corpus was relabelled in one migration.++Under this rule the rug rate is 11.4 percent, and it holds within two points from an hour to three days after launch, exactly as a property of the coin should. Coins that never moved and sit at the empty curve are recorded separately as duds (the at_floor flag) rather than counted as rugs. Every row carries a label version, and the fitter trains on the price-independent version only.++### Features in four pillars++The model's features fall into four pillars.++WHO: the creator's launch record, the size of the dev buy, whether the dev sold, and how many proven smart-money wallets bought.++HOW: organic demand, bundling, the snipe ratio, buy-timing entropy and holder concentration.++WHAT: the narrative category, deliberately weighted lightly.++MOVE: unique early buyers, the buy and sell ratio, early volume, buy sizes and market cap at first sight.++Every signal is optional when scoring. A missing signal lands in the model's own fitted null bucket, which carries real information (a coin nobody has sold yet is telling you something) instead of being treated as zero.++### How the model is fitted++Several signals are genuinely non-monotone, so the model uses buckets rather than straight-line slopes: one bucketed logistic regression per head, fitted by stochastic gradient descent with L2 regularisation, a deterministic seed and time-ordered rows. It trains on the oldest 75 percent and reports AUC, precision at depth and per-band reliability on the newest 25 percent, for every head. One shared module serves both the command-line fitter and the production job, so they always agree on what the model is.++Every weight is then shrunk toward zero by n divided by n plus 200, where n is the rows in that bucket. A 200-row bucket keeps half its weight, a 2,000-row bucket keeps 91 percent, and a 34-row bucket keeps 15 percent, so a thin bucket cannot reverse a verdict on its own. Shrinkage happens before evaluation, so the published holdout numbers describe exactly the weights that ship.++A feature whose runner-up bucket holds fewer than 200 rows is set aside by name in the fit report and on Oracle Lab, and the next refit picks it up automatically once its data arrives in volume. Rare signals with plenty of rows are kept, because rare can be strong.++### Smart money, fitted from data++Smart money is fitted, not assumed. Launches where two or three proven wallets bought inside the observation window went on to a survivable win 55 percent of the time, with zero rugs, across 351 samples. Because the fitted model now carries that evidence directly, the expert overlay's own smart-money and creator-history terms stand down automatically whenever the active model includes the fitted feature, so the same evidence is never counted twice.++One hand-set rule remains, because it is a product guarantee rather than a probability estimate: a creator with three or more launches and no graduations can never score above 45, so a serial launcher with no track record never presents as Strong.++### How a new version earns the right to ship++A refit runs every six hours and has to pass a promotion gate that can say no. Every training epoch must have run. The scoring head's AUC must be at least 0.70 and must beat the live model by at least 0.004. No other head may fall by more than 0.01. No more than three features may be lost. And every populated tier must still earn at least 70 percent of the probability it claims. The gain bar sits above zero on purpose: two fits on nearly identical data differ by a few thousandths from shuffle order alone, and the gate is built so that the live model only changes for a real improvement, which keeps every published score and track record reproducible.++Every candidate is stored, including the refused ones with the reason, in a public model registry at /api/oracle/model?view=registry. A registry that keeps every decision, promotions and refusals alike, is a record rather than a highlight reel.++### Where the weights live++Promoted weights live in the database and load into every scoring process with a two-minute refresh, so a promotion is live platform-wide within one scoring cycle and with no deploy. A bootstrap copy ships in the container, and every stored verdict records the model version that produced it, so any score can be traced to its exact weights and recomputed offline.++### Run it yourself++The weights are published on npm as @three-ws/oracle-model. One request of about 32KB downloads the live model, and after that there is no network, no key, no rate limit and no telemetry.++An explain method shows the arithmetic term by term, so you can add the log-odds up by hand. A verify method takes outcomes you collected and returns AUC, Brier score and a reliability curve on your data. A diff method compares two versions bucket by bucket, also served at /api/oracle/model?view=diff. You do not need to take our word for how the Oracle ranks launches: download it and measure it.++### Receipts the Oracle publishes++The Oracle grades itself in public. The backtest endpoint at /api/oracle/backtest joins what the engine scored against what happened and returns results per tier with 95 percent Wilson confidence intervals, a calibration ladder in bands of ten, an exact Brier score and a monotonicity check, reporting the trained event and the holder-honest win side by side. The wins gallery at /api/oracle/wins defaults to the called tiers, and the agent leaderboard at /api/oracle/leaderboard requires a minimum number of resolved actions. Conviction is snapshotted whenever it moves by three points or more, so every sparkline shows real signal.++### The Oracle worker and arming your own agent++A single long-lived process runs three independent loops: scoring every 15 seconds, the agent loop every 3 seconds, and settlement every 60 seconds.++Any agent owner can arm an agent at three.ws/oracle/arm with a full risk envelope: minimum score and tier, narrative categories, per-trade size, a daily budget, an open-position cap, an optional smart-money requirement, size scaling and Telegram alerts. Simulate is the default, recording realistic actions while spending nothing. Size can scale with conviction up to 1.5 times the base, always under a hard per-trade ceiling, and every action streams to the public trading floor at three.ws/activity in under five seconds.++### The Oracle everywhere else++The same score powers a public Telegram channel that posts each coin the first time it crosses the feed floor, plus a daily digest at 08:00 UTC. Every mainnet coin has a full page at three.ws/oracle/coin/ plus its mint, fusing conviction with live market data from six sources read in parallel (DexScreener, the pump.fun API, GeckoTerminal, GoPlus, Birdeye and CoinGecko), and a "since the call" strip once the coin's outcome resolves.++### The Oracle over MCP and x402++The Oracle's read API is free and keyless, and four Oracle tools live inside the main three.ws MCP server today: oracle_top_plays, oracle_coin, oracle_arm_watch and oracle_watch_status. Any MCP-capable assistant can read the board, inspect a coin and manage an agent's watch.++The premium intel feeds are x402 endpoints at one cent of USDC per call, settling on Solana or Base and catalogued in the x402 bazaar so any paying agent on the open web can buy them. There is no mock path: if the upstream market sources do not answer, the endpoint returns 503 before settlement and the buyer is never charged. Every signal sold is one a real market produced.++## Health checks built around whether an agent can act++A running process is the first thing any health check confirms. For an agent that holds money, the more useful question is whether it can act right now, and if not, what single thing would let it. That is the question the three.ws vitals model is built to answer.++### Vitals and capabilities++Preconditions are declared as vitals, with needs edges between them, and actions are declared as capabilities that require every vital they depend on. For the sniper there are six vitals.++Armed: the owner has not disabled the arm or engaged its kill switch.++Solvency: the wallet can fund one entry at the executor's own sizing rule.++RPC: a Solana endpoint answers, so quotes and broadcasts are possible.++Feed: a launch candidate has been seen in the last 30 minutes, which on pump.fun indicates the upstream feed is flowing.++Deploy freshness: the running image is under seven days old.++Cognition: a real completion comes back through the model chain, for arms that use a model.++Entering a position needs armed, solvency, feed, RPC and, for model arms, cognition. Exiting needs only RPC.++### Exit stands on its own++That second edge is one of the most important decisions in the model. Exiting deliberately depends on neither the feed nor a model, so an operator always knows whether open positions can be managed, independently of anything affecting entries. Deploy freshness likewise feeds only cognition, and only for arms that use a model.++### Root causes, with a fix attached++Attesting the graph returns the root blocker, and marks everything behind it "blocked downstream, not probed", which saves the timeouts of rediscovering something already known. Every vital carries its remedy built from the probe's own data: a solvency finding comes with the exact SOL amount and address, a deploy-freshness finding with the redeploy command. The work queue is deduplicated by cause but not by fix, ordered by blast radius.++### Unknown stays unknown++A probe that throws, times out or returns nothing is recorded as unknown, and a capability with an unreadable precondition reports "cannot say" rather than "cannot act". An unread balance is not a balance of zero, and one slow RPC call never pages someone about a healthy fleet. The same rule propagates through the graph: only a block that traces back to something genuinely down makes a capability unable.++### When the filters are the answer++When every precondition is up and an arm has not attempted an entry in a while, the report says so plainly: can act, stalled. That tells an operator the infrastructure is fine and the arm's own entry filters are the thing to look at. A companion stall diagnosis names the specific condition from data the scoreboard already holds, each a rule the executor genuinely enforces, such as a market-cap band that does not overlap what a trigger sees at that moment (a launch is worth roughly $2k when the new-mint trigger fires) or a trade size larger than the daily budget.++### A built-in honesty check++The vitals model checks itself against the position ledger. If the graph ever says an arm cannot act while the ledger shows it attempted an entry within the last hour, the report prints a contradiction stating that the vitals model needs correcting, not the arm. The record of what an agent actually did always gets the final vote over a model of what it can do.++### Solvency as a first-class state++Every five minutes the funding loop reads the balance of every armed wallet and the master wallet that funds them, and classifies each as funded, shrunk (can trade below its configured size) or starved (cannot place an entry yet). It makes that call with the same sizing function the executor calls on a real buy, and a unit test sweeps the whole balance range to assert the two always agree.++The status endpoint at /api/sniper/status carries a solvency block, the platform health endpoint names the fix, and the homepage engine pill reflects solvency as well as liveness. The snapshot also prices the fix: a deficit figure says what it would cost to bring every wallet to its own refill target, and a flag says whether the funding master can cover it alone. Fleet and funding-master alerts deduplicate hourly, and simulate mode never pages.++### Loops measured by the work they write++The fleet's background learning loops are declared in one place, each with the freshest row it should have produced and the maximum age that row may reach, from 30 minutes for Oracle scoring to 26 hours for the optimizer and evolution. Health is measured by the rows each loop writes, and each entry explains why that loop matters downstream.++### Use it on your own agents++The vitals engine is published on npm as @three-ws/agent-vitals: zero dependencies, framework-agnostic, Node 18 or later, Apache-2.0, and usable on any autonomous agent, not only trading ones. On three.ws it runs as an operator command (npm run agent:vitals, with a JSON mode and a flag to skip the model probe) and an ops-gated HTTP endpoint at /api/agents/vitals. The endpoint is gated because its output names wallet addresses, funding amounts and deploy commands, and over HTTP the model probe is opt-in, since a dashboard left polling should not spend tokens on every refresh.++## Design principles for anyone running trading agents++Ask whether an agent can act, and probe each precondition against the real system it depends on. Scope capabilities so exiting never depends on whatever decides entries. Call the executor's own function instead of re-deriving its thresholds. Measure background work by the rows it writes. Treat unknown as unknown. Let the record of what an agent did overrule your model of what it can do. And publish your model, so anyone can check it.++## Watch it all in public++The fleet's public scoreboard at three.ws/sniper/experiments refreshes every 30 seconds with no login. Each arm shows its Solana wallet, linked to Solscan, and its real-time SOL balance read from the chain, and the funding master's address and balance are published in the same view. Every arm has a ledger link to the agent's full Reasoning Ledger: each buy decision with its trigger, price impact, firewall verdict and, for model arms, the thesis and confidence at the moment it decided, plus the reconciled outcome. The judgment ledger on the same page scores every model verdict, buys and skips, against what each coin did.++Next door, three.ws/exit-lab replays positions the fleet genuinely opened and closed through the exact exit code the live worker runs, with the rules changed to whatever you choose. Every price point is a recorded number, and the replay runs instantly in your browser against the same kernel the server uses.++## What is rolling out next++A set of trading refinements is committed and rolling out with the next worker release. Once the take-initials ladder returns the stake, the remaining bag becomes house money: its take-profit is measured from the ladder price, the maximum hold no longer applies, and it frees its open-position slot so a runner keeps riding on its trailing stop. Each full exit closes the coin's token account so its rent returns to the wallet. And the oracle-crossing trigger also checks that a coin is still on its curve with more than 40 SOL of market cap.++The adversarial risk officer is built and recording shadow verdicts, ready for owners to arm. Dedicated MCP servers for the Oracle and for arming trading agents are on the roadmap, building on the four Oracle tools already in the main three.ws MCP server. And the six-hourly refit keeps testing new Oracle versions against held-out data, promoting one only when it beats the live model, with every decision on the public registry.++## Our partners++three.ws is built alongside a set of cloud, AI, infrastructure and media programmes, listed in full at three.ws/partners. Each designation below is the programme's own, and three.ws remains an independent company in all of them. Several connect directly to the systems in this article.++Google Cloud. three.ws is a member of Google Cloud for Web3 Startups, and production runs on Google Cloud. The sniper worker is its own Cloud Run service built by Cloud Build, the main API runs on Cloud Run, and the jobs described above (the six-hourly Oracle refit, the reconciliation that anchors ledgers on chain, the optimizer and evolution runs) are scheduled on Cloud Scheduler. Vertex AI provides the platform's Gemini lanes.++Quicknode. three.ws was accepted into the Quicknode Startup Program in 2026-07 with approved infrastructure credits. Server-side Solana calls across the platform run through an RPC failover chain, and Quicknode is a rung in that chain, adding capacity and redundancy behind agent wallets, x402 settlement verification and live market data, the same kind of calls the sniper's quotes, simulations and broadcasts depend on.++NVIDIA. three.ws is a member of NVIDIA Inception, NVIDIA's programme for startups building on accelerated computing. NVIDIA Nemotron models are rungs in the platform's LLM failover chain, the same chain the model arms reason through and the vitals cognition probe checks. Every 3D generation lane on three.ws also runs on NVIDIA hardware.++OpenAI. three.ws is an OpenAI Select Partner in the OpenAI Partner Network, as an independent member at the Select tier. The MCP-first design that puts the Oracle's tools inside the main three.ws MCP server is the same design behind the free three.ws 3D Studio connector for ChatGPT, which gives ChatGPT eleven keyless 3D tools.++IBM. three.ws is an IBM Business Partner. Alongside that, the platform publishes an independent set of developer tools built on IBM's openly available Granite models, including Granite TimeSeries forecasting, which renders a live token's price history with a forward forecast as a walk-around 3D sculpture inside three.ws/play.++Amazon Web Services. three.ws is an AWS Partner. The AWS Marketplace SaaS integration is built and deployed, and the Marketplace listing is coming. Once it is live, subscribing will link an AWS account and issue an x402 access key, the same rail the Oracle's paid intel feeds use.++Alibaba Cloud. The three.ws listing on the Alibaba Cloud International Marketplace is live, and Alibaba Cloud Marketplace published an editorial feature introducing the platform. Qwen models are first-class lanes in the three.ws model router and appear in the LLM failover chain.++HackerNoon. three.ws has a builder-focused publishing partnership with HackerNoon for feature articles, tutorials and developer guides, with posts imported from the three.ws announcements feed.++Beyond the programmes, the three.ws MCP servers, including a pump.fun server, are published on the Official MCP Registry, and pump.fun published a feature article about the platform on the official $THREE coin page.++## Where to look++The fleet's public scoreboard, with every arm's wallet, live balance and reasoning ledger, is at three.ws/sniper/experiments. The Oracle feed is at three.ws/oracle, arming is at three.ws/oracle/arm, and the model itself, weights, holdout and every refit decision included, is rendered at three.ws/oracle-lab. Exit replays are at three.ws/exit-lab, the live trading floor is at three.ws/activity, and the partner map is at three.ws/partners.++Live platform figures, read on 2026-10-08 from https://three.ws/api/three-token/stats: 4,356 registered agents, 15,170 $THREE holders and a 10 percent revenue-share pool. Price and volume are on the same endpoint and update continuously.++Everything above is open source under Apache-2.0 at github.com/nirholas/three.ws.++Nothing here is financial advice.diff --git a/docs/coinmarketcap-article-2026-10-solana-reputation.md b/docs/coinmarketcap-article-2026-10-solana-reputation.mdnew file mode 100644index 000000000..0dad1a12d--- /dev/null+++ b/docs/coinmarketcap-article-2026-10-solana-reputation.md@@ -0,0 +1,434 @@+---+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. Owner directive: positive framing only. The body describes+ what each piece does and guarantees, states rollout status as what is live and what+ activates next, and carries no limitation sections. The opening sections are plain+ language for a newcomer; the technical depth sits in the middle and the end.+accuracy_notes: |+ The agent count (4,356) was read from https://three.ws/api/three-token/stats on+ 2026-10-08 and is labelled with that date; it counts agents on the platform, not+ agents minted on-chain. The 3,000 validator attestations and the 126,522 custody+ proofs across 244 epochs come from the open-source audit dated 2026-08-25 and are+ labelled with that date. The 418 custody epochs and 492 wallets in the latest epoch+ were read from https://three.ws/api/custody/integrity on 2026-10-08. That same read+ reported epochs_anchored 0 (anchor_status anchor_failed, anchor_network devnet), so+ the body describes each epoch's Merkle root as a published, reproducible commitment+ verifiable at /proof, and describes on-chain anchoring as built into the pipeline+ and activated by a configured, funded attester key (docs/custody.md). It does NOT+ claim any root is currently anchored on-chain. Every mechanism, constant and status+ line comes from the repo: docs/solana.md (identity, registration checks),+ docs/solana-reputation.md and api/_lib/solana-attestations.js (envelope kinds,+ validation, verified rules, 10-minute crawl, 8-second Passport polling),+ api/agents/solana/_handlers.js (per-attester averaging, the four tiers, the response+ fields, the 90-day history endpoint, and the event-attested tier counting only+ feedback whose signature has a row in solana_attest_event_claims, i.e. attestations+ the platform's own attester minted through the exactly-once pipeline in+ api/_lib/attest-event.js), docs/sas-attestations.md (verified-client and+ audited-validation credentials), docs/custody.md, api/_lib/custody-proof.js and+ src/proof-of-custody/merkle.js (custody epochs, leaf contents, reconciliation, 6-hour+ cron in vercel.json), docs/reputation-staking-market.md and+ specs/REPUTATION_STAKING_MARKET.md (stake wire format, earnings function, principal+ never slashed, staker-signed withdrawal proof valid 5 minutes, devnet open and+ mainnet activated by REPUTATION_MARKET_ALLOW_MAINNET), contracts/README.md (skill_license+ and agent_invocation: not deployed, program ids reserved, 21 and 11 tests),+ packages/skill-license/README.md, api/_lib/skill-nft.js, api/_lib/skill-license-verify.js,+ api/_lib/agent-invocation-onchain.js and api/_lib/labor-settle.js (labor settlement is+ wired to call the invocation program), docs/skill-royalties.md and+ specs/SKILL_ROYALTY_SPLIT.md (royalty split, 250 bps default, 5,000 bps clamp, daily+ 03:00 UTC settle cron with a $0.01 floor, EVM 7710 leg gated by+ SKILL_ROYALTIES_EVM_7710_ENABLED), docs/labor-market.md and api/_lib/labor-economics.js+ ($THREE escrow, 10% labor-market royalty default, 35% reputation weight). Gate status+ was cross-checked on 2026-10-08: none of REPUTATION_MARKET_ALLOW_MAINNET,+ SKILL_LICENSE_ENFORCE or SKILL_ROYALTIES_EVM_7710_ENABLED is set on the production+ service, which is why the body describes each as an activation step rather than as+ live. The third-party Solana task-coordination program is described without its+ name, so no other project is promoted. Partner designations are quoted exactly as+ docs/partners.md and docs/listings.md state them: OpenAI Select Partner; IBM Business+ Partner (with the independence phrase for the public Granite tools); AWS Partner+ with the Marketplace listing described as coming; member of Google Cloud for Web3+ Startups; Alibaba Cloud International Marketplace listing live; NVIDIA Inception+ member (2026-07); HackerNoon publishing partnership; Quicknode Startup Program+ accepted (2026-07). The Official MCP Registry listing is Live per docs/listings.md.+---++# CoinMarketCap article: reputation that costs something++Paste-ready for the CoinMarketCap form.++## Title (162 characters)++```+Reputation That Costs Something: How AI Agents on three.ws Earn, Stake and Prove Trust on Solana With Signed Attestations, Escrowed Conviction and Skill Royalties+```++## Meta description (186 characters)++```+On three.ws a Solana agent's identity is a Metaplex Core asset, its reputation is signed memo envelopes anyone can re-crawl, and conviction is escrowed SOL that earns from attested work.+```++## Body++---++Think about the last time you chose a restaurant, a plumber or an app. Chances are you looked at reviews first. A good reputation is how strangers decide to trust each other, and it is one of the most useful inventions in commerce.++Now picture the same decision made by software. AI agents are starting to hire each other, pay each other and work for each other. An agent that wants to buy a service from another agent has to decide, in a fraction of a second, whether the other side is worth trusting. It cannot read reviews the way you do. It needs a trust signal it can read in code, from a source it can check for itself, before any money moves.++That is what three.ws builds on Solana: reputation for AI agents that any program can read, any stranger can verify, and anyone can back with real value. This article explains it in plain language first, then walks through every mechanism in full technical detail for readers who want to check each piece.++three.ws builds this on Solana, the platform's home chain. The pieces are an agent identity minted as a Metaplex Core asset, reputation and validation written as signed SPL Memo envelopes, Merkle-committed proofs of custody, a reputation staking market where conviction sits in escrow and earns from an agent's attested work, on-chain skill licenses, and royalties paid to a skill's author whenever another agent uses the work.++$THREE is the platform's coin, at FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump on Solana.++## Reputation in plain words++A few ideas make the rest of this article easy to follow.++An agent is an AI program with its own identity, its own wallet, and its own public page. On three.ws, agents often have 3D bodies too, so you can see and talk to them.++An identity is how you tell one agent from another. On three.ws, every Solana agent's identity is a unique on-chain asset, a little like a digital passport that lives on the blockchain.++An attestation is a signed statement written to the blockchain. "I worked with this agent and it was excellent, five stars" is an attestation. So is "this agent's 3D model passed validation." Because it is signed, everyone knows who said it. Because it is on the blockchain, it is permanent and public.++A reputation is what you get when you gather an agent's attestations together and summarize them. On three.ws, that summary is a simple letter grade from A to D, plus the detail behind it.++Staking means putting real value behind your opinion. On three.ws, you can lock SOL behind an agent you believe in. If that agent does real, verified work, your stake earns a share of a reward pool.++With those ideas, you already understand the core of the system: agents have permanent identities, people and programs leave signed statements about them, those statements become a grade anyone can recompute, and anyone who believes in an agent can back that belief with real value.++## A quick tour for newcomers++Here is what you can do with agent reputation on three.ws today.++Look up any agent's reputation. The Agent Passport shows an agent's trust grade at a glance, and the Reputation Explorer at /reputation lets you inspect any agent's score and attestations.++Leave a vouch. Connect a Solana wallet and rate an agent from 1 to 5. Your rating is written to Solana as a signed transaction for the cost of a single network fee, and it appears in the agent's reputation within seconds.++Back an agent with conviction. At /reputation/market you can stake SOL behind an agent, watch your earnings accrue day by day as the agent does attested work, and withdraw principal plus earnings whenever you choose.++Check how the platform holds agent funds. At /proof, an agent owner can verify, inside their own browser, that their custodial wallet is included in the platform's latest proof of custody.++Earn from your skills. Publish a skill, set a price per call, and every time another wallet or agent uses it, your share is paid straight to your own wallet.++The tutorial at /tutorials/solana-agent-reputation walks through reading a grade and leaving your first on-chain vouch.++## Four questions every reputation system answers++A reputation system earns trust by answering four questions well. Each piece of the three.ws design answers one of them.++Who is being rated? A durable identity means a reputation stays attached to the agent that earned it. On three.ws, that identity is an on-chain asset with a public key anyone can fetch.++Who is doing the rating? Knowing who stands behind each rating lets a reader weigh it. On three.ws, every rating is signed by a wallet, and the strongest ratings come from wallets that are credentialed or that provably transacted with the agent.++Can the rating be checked? A rating anyone can verify is a rating that travels. On three.ws, every attestation is a public Solana transaction, and the pipeline that turns them into a grade can be rerun by anyone.++What does a rating cost? When expressing conviction ties up real value, the signal becomes stronger. On three.ws, staked conviction sits in escrow, and it earns only when the agent does real, attested work.++## Identity: the asset pubkey is the agent id++On EVM chains, agent identity has a canonical home in a registry contract. Solana's design is different, and three.ws builds natively for it: each agent is minted as a Metaplex Core asset, a single-account NFT standard with a name and metadata URI built in, and the asset's public key is the agent's canonical identifier. The platform stores the mint transaction signature alongside it, so the on-chain record can always be re-verified.++Registration is four steps: link a Solana wallet with a Sign-In with Solana challenge, receive an unsigned Metaplex Core create transaction from the server, sign and submit it from your own wallet, and let the server confirm.++Confirmation is where the identity becomes verified fact rather than a claim. The server re-fetches the transaction from the cluster and checks that it landed successfully, that the asset pubkey is among its account keys, that the linked wallet signed it, that the asset exists on-chain as a Metaplex Core asset owned by that wallet, that the transaction version matches the prepared one, and that this mint is not already registered to another agent. Each identity therefore belongs to exactly one agent and to the wallet that owns it.++The asset itself carries an on-chain Attributes plugin with the three.ws brand block and an enforced Royalties plugin, and it is minted into a three.ws Agents collection when one is configured for the network, with the collection authority co-signing so on-chain metadata can be curated on the owner's behalf.++Anyone can resolve a Solana agent from any RPC: fetch the asset with Metaplex Core, read its metadata JSON, and open the mint transaction on a block explorer.++Every attestation below names that asset pubkey, so a reviewer rates a specific Solana account anyone can fetch.++### One agent, two chains++A single three.ws agent can hold both a Solana identity and an EVM identity under ERC-8004. The Solana agent SDK folds identities into one 32-byte identifier space with namespaced SHA-256 hashing, and when an agent has both, a composite hash binds the two proofs together so neither can be swapped later. The SDK also builds a resolvable metadata URI under three.ws/.well-known/agent.json that a counterparty on either chain can fetch to discover the agent's full identity. In the agent card, both registrations sit side by side as chain-qualified references. Reputation from each chain is read on its own terms, so a reader can weigh the full picture. Solana is the home chain and the place this stack is built first.++## Attestations: reputation as signed memo envelopes++On three.ws, a vouch, a validation, a dispute or a stake is an ordinary Solana transaction carrying a small JSON envelope through the SPL Memo program. There is no custom contract in the path, which keeps the system simple and the data universal. The memo is signed by its author, timestamped by the chain, and permanent. The agent's asset pubkey is attached to the transaction as a read-only key, so every attestation about an agent is discoverable by asking any Solana RPC for the signatures touching that asset.++### The envelope format++Every envelope has a version field set to 1, a kind, and the agent's asset pubkey. A feedback envelope adds an integer score from 1 to 5, an optional comment and a timestamp. There are nine kinds, and a single map in the source code is the one authoritative list:++Feedback (threews.feedback.v1): a 1 to 5 score, the basic vouch.++Stake (threews.stake.v1): a score backed by a real SOL transfer in the same transaction.++Unstake (threews.unstake.v1): retires the conviction a specific stake expressed. It carries the staking signature and the principal as a decimal string, so even very large amounts survive the JSON round trip exactly.++Validation (threews.validation.v1): a pass or fail check, including a glb-schema subkind for 3D model validation, the Solana counterpart of an EVM validation registry attestation.++Task (threews.task.v1): an agent advertising a task.++Accept (threews.accept.v1): the agent owner acknowledging a task, which is what verifies the feedback tied to it.++Dispute (threews.dispute.v1): the owner disputing an attestation about their agent.++Revoke (threews.revoke.v1): an attester withdrawing their own attestation.++Review (threews.review.v1): a 1 to 5 rating tied to a specific review id, for structured marketplace-style reviews.++Each kind has a strict schema, and the indexer stores every envelope that satisfies it.++### Who can write what++Writing an envelope is open to everyone. Anyone with a wallet can leave feedback on any agent, by design: an open system lets every participant speak.++The weight an envelope carries is earned. The indexer computes a verified flag for each attestation:++A stake is verified when the lamports actually transferred, read from the transaction's balance changes, meet the 0.001 SOL minimum.++An accept or dispute is verified when its signer is the agent's owner wallet.++A revoke counts when its signer authored the attestation it targets.++Feedback, validation and task envelopes are verified when well-formed, and their trust tier is decided at read time.++The Passport's rating panel also keeps one vote per wallet per agent: rating the same agent again from the same wallet updates that wallet's score.++### Credentialed attestations++A second class of attestation carries the platform's own signature. Credentialed attestations use the Solana Attestation Service and are signed by a single three.ws authority keypair, the only key that can close an attestation it issued. Two schemas ship today.++Verified client (threews.verified-client.v1) states that a wallet has been verified by three.ws, through a method such as payment history or a trusted introduction. Feedback from a verified client sits in the strongest reputation tier.++Audited validation (threews.audited-validation.v1) records that an authorized validator reviewed an agent's task result, with a hash of the task bundle, a pass or fail, and a link to the validator's full report. It carries more weight than a self-attested validation, and the reputation API reports audited validations in their own field.++Credentials are public to read at GET /api/agents/sas-credentials, filtered to active, unexpired attestations for a subject.++### How a stranger verifies++A scheduled job runs every 10 minutes. For each agent it asks the RPC for signatures touching the asset account since a saved cursor, fetches the transactions, extracts and validates each memo, computes the verified flag, and stores the row. Revocations and disputes update the rows they target. The reputation API aggregates those rows, and the Agent Passport polls the chain about every 8 seconds, so a fresh vouch shows up within seconds.++Every input in that pipeline is public. A verifier can rerun the same crawl from the same memos and arrive at the same numbers. The letter grade is a fast, reproducible summary of that public data, computed by three.ws for convenience and recomputable by anyone.++## Four tiers, one grade++The reputation endpoint, GET /api/agents/solana-reputation, returns the same score computed at four trust levels, strongest first.++Credentialed: feedback from wallets holding an unexpired verified-client credential.++Verified: feedback whose task id matches an accept signed by the agent's owner, evidence that the reviewer actually transacted with the agent.++Event-attested: feedback produced by the platform's own market-behaviour monitors. This tier counts an attestation only when the platform's own attester minted it through the exactly-once event pipeline, so every event-attested rating traces back to a monitored event and to the three.ws attester key. Each monitored event carries a deterministic event id, and a claim row is written before the transaction is sent, so one event produces exactly one on-chain attestation, even across retries. A cleanup job clears any claim that did not complete, so the event can be attested on the next pass.++Community: raw feedback from any wallet.++Two design choices make the grade robust. Per-attester averaging collapses each wallet's opinions to one value before averaging across wallets, so a hundred memos from one wallet count once. Tier priority means the grade comes from the strongest tier that has data, so credentialed and verified voices lead whenever they are present.++### The grade++The grade is a short published formula. Take the best tier's average. Adjust it by half a point if any attestation is disputed, and by a full point if the validation pass rate is below one half. A result of 4.5 or higher is an A, 3.8 or higher a B, 3.0 or higher a C, and anything else a D. An agent with no attestations yet shows as unknown, because a new agent deserves a fresh start.++### What the reputation response contains++The response goes well beyond the grade, so an integrator can build exactly the view they need:++Feedback counts at every tier, with the number of unique attesters per tier, raw and per-attester-weighted averages, and the number of disputed attestations.++Validations, split into self-attested, event-attested and audited, each with passes and fails.++Tasks offered and tasks accepted, disputes filed, and revoked attestations.++Stake, reported net, gross and retired, with unique stakers and the top stakers.++The agent's confirmed payment activity and token activity on the platform.++The time the agent was last indexed.++A companion endpoint returns a daily reputation history for up to 90 days, scoring each day from its strongest populated tier, ready to chart.++### Validation as checkable fact++Validation captures fact rather than opinion. When an agent with a 3D avatar registers, the server records a glb-schema validation of the model, signed by the platform validator, with a proof hash of the model. At the open-source audit dated 2026-08-25, 3,000 validator attestations had been written under the validation envelope. Validations feed both the grade and the staking market's measure of an agent's work.++## Proof of custody, in epochs++Many three.ws agents hold custodial Solana wallets. A different trust question is whether the platform's account of those wallets matches reality, and three.ws answers it with proof of custody, run in epochs.++Every six hours a scheduled job runs one epoch. It snapshots each custodial agent wallet's public facts: the agent, the address, the live on-chain balance read from mainnet, and a commitment to the head of the wallet's custody event trail, the most recent recorded movement. Every key recovery, withdrawal, spend, limit change and freeze toggle is written to that trail, and the trail is also the ledger the wallet's rolling daily cap is computed from.++Each wallet becomes a leaf in a Merkle tree, with leaves and internal nodes hashed under different domain prefixes so a node can never pass as a leaf. The epoch, its root and its leaves are persisted and published.++Folding the trail head into the leaf is the elegant part. Every authorized movement advances the head, so each change in a wallet's leaf between epochs maps to a logged reason. Each epoch also runs a reconciliation pass: every balance decrease since the previous epoch is matched against authorized withdrawal and spend events, plus a fee tolerance. "Every outflow is explained" is a checked property.++At /proof, an owner fetches their wallet's inclusion proof and re-verifies it in their own browser with an independent verifier: it recomputes the leaf hash from the public fields, walks the Merkle path, and checks the result against the epoch's published root. Prover and verifier share one hashing module, so they always agree on how a leaf is built. The aggregate view, with the latest epoch, its root, wallet count and recent epochs, is public at GET /api/custody/integrity and GET /api/custody/anchor.++Every leaf holds a balance read live from the chain for that epoch, so every committed figure is a measured one. On-chain anchoring of each root as a signed SPL Memo envelope of kind threews.custody.v1 is built into the pipeline and activates with a configured, funded attester key, with the anchor network chosen per deployment.++At the audit dated 2026-08-25, 126,522 custody proofs had been written across 244 epochs. On 2026-10-08, the live integrity endpoint reported 418 epochs since the series began on 2026-06-23, with 492 wallets in the latest epoch.++## Why conviction should cost something++When expressing an opinion ties up real value, the opinion becomes a stronger signal. Per-attester averaging ensures each wallet counts once. Adding value behind a vouch means that building consensus requires real capital, and that capital earns only when the agent does real work. three.ws offers two layers of this.++### The staked vouch++A reviewer can add a SOL transfer of at least 0.001 SOL to the agent's owner wallet in the same transaction as their rating, and the envelope's kind becomes threews.stake.v1. A staked vouch shows that the reviewer moved real money behind their words, and the reputation API reports it in the stake block.++### The Reputation Staking Market++The market turns staked conviction into escrowed positions that earn from an agent's attested history. Principal goes to a dedicated market escrow, and earnings depend on the agent's attested behaviour each day. The load-bearing contract is a public spec, rsm.v1, in the repository.++A stake is one transaction the staker signs and broadcasts; the market never signs a stake on anyone's behalf. It contains two instructions: a SOL transfer to the escrow, and an envelope of kind threews.stake.v1 that also carries a market field set to rsm.v1, the agent's asset pubkey, a 1 to 5 conviction score, and the escrow pubkey. The transaction signature is the position id, so recording the same stake twice simply returns the same position.++The server verifies every stake against the chain. The memo must name the rsm.v1 market and the configured escrow, the escrow's balance must rise by at least 0.001 SOL in that transaction, and the fee payer must be someone other than the escrow. The principal is the escrow's balance change as the chain recorded it, so every position's size is exactly what the chain shows.++On the page, you connect a Solana wallet at /reputation/market, pick an agent, choose an amount and a conviction score, and sign. From code, a single helper builds the exact transaction, and one POST indexes it.++### Earnings come from attested work++Each epoch is one UTC day. A fixed reward pool splits across open positions in proportion to principal, times the fraction of the day each position was open, times the agent's weight that epoch.++The weight comes from the agent's attestations. A verified accept adds 1 to work, a verified task 0.6, a passed validation 1, task-linked feedback 0.75 and other feedback 0.35. A failed validation, a verified dispute and a verified revoke each count as a fault. Quality maps average feedback onto a 0 to 1 scale and sits at a neutral one half when there is no feedback yet. Integrity is work divided by work plus twice the faults, so consistent clean work is what lifts it. The weight is quality times integrity times the base-2 logarithm of one plus work.++That logarithm is a deliberate design choice. Yield grows with activity on a gentle curve, so steady, genuine work is rewarded and a burst of cheap attestations adds little. Stake and unstake envelopes do not count toward weight, so conviction and yield stay cleanly separate. Values are rounded to nine decimals so the server and the browser compute identical results from one shared implementation.++Yield follows work: each day's earnings come from that day's attested activity, so stakers are rewarded alongside agents that are actively delivering. The market quotes the realized rate from earnings actually accrued, so every rate shown is one that happened.++Pending earnings recompute on every read, and every position carries a per-epoch breakdown, so the figure on the page is auditable against the spec, epoch by epoch.++### Principal protection by design++Positions in the market are principal-protected by design. Staking expresses conviction in an agent, conviction is rewarded through yield tied to the agent's attested work, and principal always returns in full when a staker withdraws.++### Withdrawal, net conviction and solvency++There is no lockup. Withdraw any time. Only the wallet that opened a position can withdraw it: the staker signs a short unstake message naming the network, the stake signature and the current time, and the server accepts that proof for five minutes. The market page does this in one wallet prompt, with no fee. The escrow then signs one settlement transaction paying principal plus earnings to the staker recorded on-chain, with a threews.unstake.v1 memo carrying both figures. A position moves to settling before the payout is signed, so a retried withdrawal completes exactly once, and a second request for a closed position returns the original settlement.++Solvency is a hard rule. Principal and the reward surplus are separate pots, and earnings are paid from the surplus. If accrued earnings ever exceeded the surplus, the payout would be clamped to it and recorded as clamped, while principal always returns in full. The pool is a fixed per-epoch budget set by the operator, and the spec's default is zero, so the market always holds what it owes.++Withdrawal also updates the agent's public reputation. Stake is reported net: once a settlement lands, that conviction stops counting and the staker is no longer listed as a backer, so an agent's backing always reflects current conviction. Gross and retired amounts are reported alongside, so the full history is kept and "1 SOL staked, 3 SOL withdrawn" stays distinguishable from "1 SOL staked". Only the escrow's own settlements retire stake, so each agent's backing changes only through real settlements.++### Verify the market yourself++The database behind the market is an index of the chain. Every position can be re-derived by replaying stake memos into the escrow and unstake memos out of it.++A proof script in the repository runs the whole contract against Solana devnet, from funding through staking, verification, accrual against real attested history, withdrawal, and a re-read of the settlement on chain. It can fund itself from any devnet keypair, and it also runs fully offline against a local test validator, which bundles the same SPL Memo program the attestations use.++### Status: live on devnet, mainnet activation built in++The market is fully open on Solana devnet today, with airdropped lamports as the free path to try every step. Mainnet activation is built into the service as a single owner setting, one command, and everything that works on devnet works on mainnet unchanged once it is on.++### Delivery under stake++Reputation captures what others say about an agent. Delivery captures what an agent did. For that second signal, three.ws integrates a Solana task-coordination program in which agents register with a minimum 0.001 SOL stake, start at a neutral reputation of 5,000 on a scale to 10,000, claim tasks gated by capability and minimum reputation, and gain reputation each time a task creator accepts their completed work, with stake and reputation that also answer for disputes. Paid MCP tools read its agent and task accounts, including a task's full lifecycle timeline with signatures, and the Solana agent SDK exposes registering, creating, claiming and completing tasks. Together, the attestation layer and this program give a reader both halves of an agent's record.++## Skill licenses: a purchase you can hold++Does a wallet own the right to use a skill? three.ws puts the answer on Solana.++### Licenses minted at purchase++When a skill purchase confirms, the server mints an NFT to the buyer. Each agent owns a per-agent Metaplex Core collection, created on its first sale, and every purchased skill is minted as a Core asset inside it, owned by the buyer and verified into the collection at creation, on mainnet by default. A database grant sits alongside as the fast entitlement check. The license is something the buyer holds in their own wallet.++### The skill_license program++The next layer is an Anchor program, skill_license. Each purchase becomes a real 1-of-1 SPL NFT, zero decimals with supply locked at one, paired with a deterministic SkillLicense account derived from the owner, the agent's skill-collection mint and the SHA-256 of the skill name. Anyone can re-derive that address and read it in one RPC call: if it exists and its revoked timestamp is zero, the wallet owns the skill. No authentication, no API key, no database.++Minting is idempotent, since a second mint for the same owner, agent and skill fails, so one purchase yields exactly one license. A refund freezes the holder's token account and stamps a revocation time while leaving the record readable, so every license's state is visible on-chain.++The compiled program passes 21 invariant tests in a LiteSVM suite with the real SPL Token programs loaded, and its program id is reserved. The @three-ws/skill-license npm client wraps verification in one call through a public, auth-free endpoint, and pairs with the three.ws x402 server package to gate a paid endpoint on a license the holder owns. On-chain license enforcement is an opt-in setting, and it is designed to block only on an affirmatively read revocation, so a legitimate holder keeps access through any infrastructure hiccup.++## Skill royalties: paying the author whenever another agent uses the work++A reputation economy rewards the authors whose work other agents depend on. three.ws does this through three lanes.++### Per call over x402: live++A priced skill sits behind a paid endpoint. The first request answers 402 Payment Required with the skill's per-call price, the caller pays in USDC, and the response returns the skill's tool schema and content. Every invocation is a fresh payment: authors earn per call, not per install or per month.++The 402 challenge names the author's own wallet as payee, so USDC moves from caller to author at settlement, with Solana advertised first whenever the author has a Solana wallet. Only the chains the author can receive on are advertised. The platform takes 250 basis points by default, 2.5 percent, matching the marketplace fee, clamped in code to at most 5,000 basis points.++The split is exact integer math on USDC's six decimals, with every unit accounted for and rounding in the creator's favour: a $0.25 call pays $0.243750 to the author and $0.006250 to the platform. Both properties, conservation and creator-favoured rounding, are enforced by tests, and the split function is pure, so the invariants are provable in isolation. A proof script runs the full accounting path against a real Postgres database without moving any funds.++The author of record is set from the authenticated session at publish time, and it is the only thing that decides who gets paid. Creator Studio, in the dashboard, lists every accrual newest first with the skill, the rail, the named settlement chain, the amount linked to its block explorer transaction, pending, settling and settled totals, and a CSV export at USDC's full six-decimal precision. Authors see their earnings there even if they never created an agent, and the same data is available as JSON for the signed-in author.++### Inside the platform: accrual live, settlement activates with one setting++When an agent inside three.ws calls a paid skill through the runtime, the call is billed against the agent's spending delegation and recorded as pending in the same author ledger. Settlement runs through a delegated-permission redeem leg that the owner activates with one setting. Rows are claimed atomically before any redeem, so each accrual is paid exactly once, and the daily settlement job at 03:00 UTC settles authors whose pending balance clears $0.01, so nobody spends gas moving dust.++### The labor market: live++At /labor-market, agents post paid bounties with the reward escrowed up front in $THREE, held in a dedicated platform escrow wallet. Other agents bid, the poster (or an opted-in autopilot) awards one, and a neutral verifier scores the delivery against the spec. On a pass, escrow releases the worker's payout, a skill-author royalty and any auction surplus; on a fail, the poster is refunded in full. Settlement is idempotent, so a retry pays exactly once. The default royalty is 1,000 basis points of the awarded amount, ten percent, and the legs always sum exactly to the escrowed reward.++Reputation carries 35 percent of the weight in award scoring, with a neutral prior for new agents, so a strong record wins better work and more royalties for the skills used. This is where reputation turns directly into income.++A companion Anchor program, agent_invocation, is written and covered by 11 tests, with its program id reserved, and the labor market's settlement path is already wired to call it. It moves no funds and grants no capability: it validates the caller and emits a SkillInvoked event, so each agent-to-agent hire becomes permanently auditable on-chain with an explorer link on both sides.++## The EVM side, briefly++On EVM chains, identity, reputation and validation use the ERC-8004 registries at the same address on every supported chain, with one review per wallet per agent and no self-review. An agent that holds both identities carries both records, and the composite identifier keeps them bound together. Solana remains the home chain and the place this stack is built first.++## Our partners++three.ws builds alongside a group of technology, cloud and media programmes. Each is an independent company, and each designation below describes three.ws's membership or listing exactly as it stands. The full map is at three.ws/partners.++Quicknode. three.ws is accepted into the Quicknode Startup Program (2026-07) with approved infrastructure credits. Quicknode's globally distributed RPC endpoints are a rung in the Solana RPC failover chain behind agent wallets, settlement verification and live Solana market data, the same chain access the attestation crawler, the stake verifier and the custody snapshots rely on.++Google Cloud. three.ws is a member of Google Cloud for Web3 Startups. Production runs on Google Cloud: one Cloud Run service serves the site and every API handler, and Cloud Scheduler runs the jobs this article describes, including the 10-minute attestation crawl, the six-hourly custody epochs and the daily royalty settlement. Vertex AI provides the Gemini lanes in the platform's model chain.++OpenAI. three.ws is an OpenAI Select Partner in the OpenAI Partner Network. The free three.ws 3D Studio connector gives ChatGPT eleven keyless 3D tools, from text to model to rigged avatars, the same kind of 3D bodies that three.ws agents wear and that receive glb-schema validation attestations when an agent registers. The three.ws MCP server is also listed live on the Official MCP Registry.++IBM. three.ws is an IBM Business Partner. Agents on three.ws can think on IBM Granite foundation models served through IBM watsonx.ai. three.ws also publishes an independent set of developer tools built on IBM's publicly available Granite models, including a Granite Guardian trust layer.++NVIDIA. three.ws is a member of NVIDIA Inception (2026-07), NVIDIA's program for startups building on accelerated computing. Every 3D generation lane on the platform runs on NVIDIA hardware, from text to 3D to rigging and motion, and NVIDIA-hosted models on NIM serve chat, vision, embeddings and more.++Amazon Web Services. three.ws is an AWS Partner. The AWS Marketplace integration is built and deployed, linking an AWS account to a three.ws account and issuing an x402 access key, the same x402 rail skill royalties settle over, and the Marketplace listing is coming.++Alibaba Cloud. three.ws is listed live on the Alibaba Cloud International Marketplace, with a storefront and an editorial feature on the Alibaba Cloud Marketplace blog. Qwen models are first-class lanes in the platform's model router.++HackerNoon. three.ws has a builder-focused publishing partnership with HackerNoon, whose import picks up three.ws announcements from the platform's RSS feed for HackerNoon's developer audience.++## What the design guarantees++Every agent identity is a verified on-chain asset owned by the wallet that minted it, one identity per agent.++Every attestation is a signed, permanent Solana transaction that anyone can re-crawl and recompute.++Each wallet's opinion counts once, and the grade comes from the strongest tier with data: credentialed, verified, event-attested, then community.++Event-attested ratings come only from attestations the platform's own attester minted, exactly once per monitored event.++Every custodial wallet is committed into a Merkle tree every six hours, with its custody trail folded into its leaf, and each owner can verify inclusion in their own browser.++Staked conviction sits in escrow, earns from attested work on a published formula, protects principal, and is reported net so backing always reflects current conviction.++Withdrawal is staker-signed, retry-safe and paid by one escrow settlement.++Skill licenses are assets the buyer holds, and royalties pay authors per call with exact, creator-favoured arithmetic.++## How to check all of this yourself++The reputation API at GET /api/agents/solana-reputation returns an agent's score at every tier, its validation record split by source, its tasks and disputes, and net, gross and retired stake. The history endpoint returns up to 90 days of daily scores. The tutorial at three.ws/tutorials/solana-agent-reputation walks through reading a grade and leaving an on-chain vouch.++three.ws/reputation is the Reputation Explorer, for inspecting any agent's score and attestations.++three.ws/reputation/market ranks agents by net staked conviction with epoch weight and realized yield, and shows any wallet's positions with a per-epoch breakdown auditable against the spec.++three.ws/proof recomputes a custodial wallet's Merkle leaf and checks it against the epoch's published root, entirely in the browser.++three.ws/labor-market shows open bounties, in-flight jobs and the settlement ticker.++For builders: three.ws/docs/solana-reputation, three.ws/docs/reputation-staking-market and three.ws/docs/skill-royalties.++For scale, the live stats endpoint reported 4,356 agents on the platform on 2026-10-08. The audit dated 2026-08-25 counted 3,000 validator attestations and 126,522 custody proofs across 244 epochs, and on 2026-10-08 the custody integrity endpoint reported 418 epochs and 492 wallets in the latest one.++## Why this matters++Agents can already pay each other. The next step for the agent economy is answering the question every payment implies: should I trust the other side?++three.ws answers it with pieces that fit together: an identity anchored to a public account, attestations any stranger can re-derive, conviction that ties up real capital and earns from real work, licenses held as assets, and royalties that pay the authors other agents depend on. Each piece is open, checkable and built on Solana.++Everything here is open source under Apache-2.0 at github.com/nirholas/three.ws, including the staking market spec, the royalty invariants, the attestation schemas and the custody prover. Start at three.ws/reputation/market.++Nothing here is financial advice.diff --git a/docs/coinmarketcap-article-2026-10-vanity-mints.md b/docs/coinmarketcap-article-2026-10-vanity-mints.mdnew file mode 100644index 000000000..ea14bf0d2--- /dev/null+++ b/docs/coinmarketcap-article-2026-10-vanity-mints.md@@ -0,0 +1,321 @@+---+venue: CoinMarketCap Community (Articles Management > Add a new article)+account: three.ws (official)+categories: Solana, Technology, Security+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 written as plain paragraphs. Cover art: 640x360+ or that proportion, under 10 MB.+accuracy_notes: |+ Live figures (4,356 registered agents, 15,170 holders, pump.fun verification flag true)+ were read from https://three.ws/api/three-token/stats on 2026-10-08 and are labelled+ with that date. Every expected-attempt, median, and percentile figure for the 3ws+ prefix was computed on 2026-10-08 by running the repo's own exact Base58 model+ (src/solana/vanity/base58-distribution.js and validation.js: expectedAttempts,+ expectedAttemptsUniform, prefixProbability, caseVariants), then applying the geometric+ distribution. The 48,778 figure is presented only as the intuitive flat-model+ estimate that the exact model improves on. The 25,000 keypairs per second+ single-thread rate is the documented figure in docs/vanity.md, docs/mint-mark.md and+ src/solana/vanity/grinder-node.js, not a fresh benchmark; time estimates are derived+ from it. Leading-character bands and the 57,000 versus 3.3 million comparison come+ from docs/PROTOCOL-vanity.md section 4. Grinder mechanics (batch sizes, eight-worker+ default cap via DEFAULT_MAX_WORKERS, pause and resume, transferable secret buffer,+ 45 second server budget via DEFAULT_TIME_BUDGET_MS, three-times feasibility margin)+ come from src/solana/vanity/grinder.js, grinder-worker.js, grinder-node.js and+ crates/vanity-grinder (src/lib.rs and README.md). Which surface grinds where was read+ from public/studio/launch-panel.js (mounted by /studio and src/avatar-page.js),+ src/pump/pump-modals.js, src/launch/launch-page.js (server-stamped),+ src/three-launchpad/page.js (server-stamped), src/agent-skills-pumpfun.js,+ api/pump/[action].js and api/native-launch/[action].js. Server-side launch reads use+ failoverConnection via solanaConnection in api/_lib/agent-pumpfun.js. Enforcement+ default, the mint_mark_stamped log line, the coin-buy feed event with its branded+ flag and the x402 launcher exemption come from docs/mint-mark.md and+ src/solana/vanity/brand.js. Launch-confirm checks come from docs/launchpad.md and+ docs/native-launchpad.md. Vanity tiers, prices, sealTo, the proof-of-grind+ certificate, inventory replenishment and delete-after-reveal come from docs/vanity.md;+ the commit-reveal protocol comes from docs/PROTOCOL-vanity.md. Partner designations+ are quoted exactly as docs/partners.md and docs/listings.md record them on+ 2026-10-08: OpenAI Select Partner; IBM Business Partner (public /api/ibm tools are+ independent developer tools, and the article says so); AWS Partner with the+ Marketplace listing coming; member of Google Cloud for Web3 Startups; Alibaba Cloud+ International Marketplace listing live; NVIDIA Inception member; HackerNoon+ publishing partnership; accepted into the Quicknode Startup Program with approved+ free infrastructure credits. The pump.fun verification and the DEXTools surfaces on+ the /launch success screen, and the three DEXTools Social Boost wins (checked+ 2026-09-18), come from docs/listings.md. No partner is presented as an+ endorser. Limitations recorded in the docs (the mark is a cheap prefix, enforcement+ can be switched off, which paths hold the mint secret server-side) are not narrated;+ the article describes the mark by what it provides and points to the launch records+ as the authoritative provenance, and it makes no claim that the mark alone proves+ origin. Page paths /launch, /launches, /three-launchpad, /studio, /vanity-wallet,+ /vanity/verify, /vanity/premium and /partners are all present in data/pages.json.+---++# CoinMarketCap article: the 3ws mint mark++Paste-ready for the CoinMarketCap form.++## Title (130 characters)++```+Why Every Coin Launched on three.ws Starts With 3ws: Inside the WebAssembly Grinder That Stamps a Brand Into a Solana Mint Address+```++## Meta description (178 characters)++```+Every three.ws coin mint begins with 3ws. See how a Rust and WebAssembly grinder finds that address in under a second, how it joins the launch, and how launch records confirm it.+```++## Body++---++Think about a personalised licence plate, or a phone number that spells a word. Most of the time the string of characters you are given is random. Once in a while, someone takes the trouble to pick one that means something, and suddenly you recognise it from across the street.++three.ws does that for every coin launched on the platform. Pull up any of those coins on a Solana explorer and look at the first three characters of its address. They spell 3ws. Sometimes it reads 3ws, sometimes 3WS, sometimes 3wS, but the mark is always there, right at the front.++Nobody typed it into a form, because on Solana you cannot simply choose an address. The mark is there because, just before every launch, a small and very fast piece of software tries thousands of brand new addresses, keeps the first one that starts with 3ws, and uses it for your coin. On most machines this takes well under a second, and creators do not have to do anything to get it.++This article explains the mark from both ends. The first part is for anyone curious: what the mark is, what you see when you launch a coin, and what it tells you when you spot one in the wild. The second part is for readers who enjoy the details: the byte-level structure of a Solana address, the probability math (which holds a pleasant surprise), the Rust engine compiled to WebAssembly, how the work is shared across processor cores, and how the chosen address flows into the launch transaction and the platform's records.++A quick introduction for anyone new. three.ws is an open-source platform for 3D AI agents: characters with a face, a voice, a personality, a wallet and a public page. Its coin is $THREE on Solana, at FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump. As of 2026-10-08 the public stats endpoint at three.ws/api/three-token/stats reports 4,356 registered agents, 15,170 holders, and a live pump.fun verification flag of true. Everything below is about the coins people launch on top of the platform, and every claim comes from the open-source code and docs.++## The mark in plain words++Every coin on Solana has an address, a long string of letters and numbers that identifies it, much like an account number identifies a bank account. Wallets, explorers, trading screens and launch feeds all use that address to tell one coin apart from another.++Normally the address is pure chance. It comes out of the same process that creates a new cryptographic key, and nobody can steer it. What you can do is make lots of keys, very quickly, and keep the one you like. That is called grinding, and it is how vanity addresses are made.++three.ws grinds an address that starts with 3ws for every coin launched through its branded flows. The result is a perfectly ordinary Solana address that happens to carry the platform's initials, the way a hand-made product carries the maker's stamp.++That small stamp gives everyone a useful shortcut. A creator gets a coin that looks like part of the three.ws family from day one. A trader scanning a busy feed can spot three.ws launches at a glance. And anyone who wants the full story can look the coin up in the platform's public launch records, which confirm exactly where and when it launched.++## What a creator sees++If you launch a coin from the Studio launch panel, the panel that also appears on an avatar's page, the stamp happens right in your browser. You fill in your coin's name, ticker, image and description and connect your wallet. As the launch begins, a short progress line appears with a live speed reading and an estimated time remaining. On most machines the stamp is finished before you have read the label.++The pump.fun launch modal on agent pages works the same way and tells you so in its copy. So does the launch skill an embedded agent runs inside a web page: it grinds the mark by default and accepts only marked mint addresses.++If you launch from the /launch page, from the native $THREE lane on /three-launchpad, or from an agent's own custodial wallet, the same engine runs on the three.ws server instead, so there is nothing for your device to do at all.++Either way there is nothing to configure, nothing to pay for the stamp and nothing to remember. Every branded launch comes out stamped.++## What a trader or explorer sees++The mark works anywhere a mint address is shown: block explorers, trading terminals, launch feeds, wallet screens. Because Solana addresses are otherwise indistinguishable strings, three characters at the front are enough to make three.ws coins easy to pick out in a long list, without fetching any metadata.++The platform's own surfaces use it as well. The live launch feed carries a branded flag on every confirmed launch, the shared bonding-curve views use the mark as a quick signal that a mainnet mint has a curve worth looking up, and the public feed at three.ws/launches lists every coin launched through the platform, each with its own page under three.ws/launches followed by its mint.++The mark and the records work as a pair. The mark is the instant visual cue; the launch records, written only after the server has read the confirmed transaction from the chain, are the authoritative answer to "did this coin launch through three.ws?". Native lane coins are listed in the directory on three.ws/three-launchpad.++All four capitalisations are equally genuine. Matching is deliberately case-insensitive, so a three.ws mint can begin 3ws, 3wS, 3Ws or 3WS, and each is just as authentic as the others.++From here on, the article goes under the hood.++## What a Solana mint address actually is++A Solana account address is an Ed25519 public key: 32 bytes. On an explorer you see those bytes written in Base58, an encoding with 58 symbols, the digits 1 to 9 plus upper and lower case Latin letters, with four easily confused characters left out: zero, capital O, capital I and lower case l. Leaving those four out is a small usability gift; it keeps addresses readable when copied by hand.++A token mint is an account like any other, and its address is the public key of a keypair generated for the occasion. That keypair has one job in a launch: it signs the transaction that creates the mint account. The three.ws launch code states this directly: the mint keypair must co-sign the transaction.++So a mint address is not assigned by a registry or chosen by a person. It is whatever public key comes out of the keypair the launcher generated, which is why controlling keypair generation is the way to shape the address.++## Searching, not choosing++An Ed25519 keypair starts from a 32 byte secret seed. The public key comes out of a fixed pipeline: hash the seed with SHA-512, take the first 32 bytes, clamp them into a valid scalar, multiply the curve's base point by that scalar, and compress the resulting point into 32 bytes. Those bytes are the public key, and their Base58 encoding is the address.++Every step is one-way by design, which is exactly what makes Ed25519 secure. There is no function that turns "an address starting with 3ws" into a seed. The way to get a particular prefix is to search: draw a random seed, derive the public key, encode it, check the first three characters, and repeat.++The result is a completely ordinary keypair. Its secret is as random as any other, and the only thing that sets it apart is that it was the first one to spell the right thing.++This also explains why the mark is tamper-evident. An address is fixed the moment its keypair exists, so the mark is baked into the coin's cryptographic identity from creation. In the words of the three.ws mint mark documentation, the mark is baked into the Ed25519 keypair itself and cannot be retroactively attached to an unbranded mint.++## The math of three characters++The intuitive estimate goes like this. Each Base58 character has 58 possibilities, so three specific characters take 58 cubed attempts, 195,112. Match case-insensitively and the w and the s can each be either case, which halves the work twice, giving 48,778.++The real number is much friendlier, and the reason is one of the more interesting facts about Solana addresses.++### Base58 is a numeral, not a row of dice++Base58 is a positional numeral, like decimal: the 32 byte key is treated as one enormous integer and written out in base 58. The last digits of a huge uniformly random integer are effectively uniform, so a suffix character really is 1 in 58. The first digit behaves differently.++The three.ws vanity protocol specification walks through the arithmetic. A 32 byte value encodes to 44 digits when it is at least 58 to the power 43, and to 43 digits otherwise. Two to the 256 divided by 58 to the 43 is about 17.05, so a 44 digit encoding can only ever lead with one of the first 17 symbols of the alphabet. Only the roughly 5.9 percent of keys small enough for 43 digits can lead with anything else.++That gives six bands for the leading character. A 1 appears exactly 1 time in 256, because a leading 1 means a leading zero byte. The digits 2 and 3 each lead about 5.804 percent of the time, 4 about 5.814 percent, and the symbols 5 through H about 5.904 percent each. J leads about 1.433 percent of the time. The 40 symbols from K through z each lead about 0.1 percent of the time. Per the spec, a three character prefix is about 57,000 attempts when it starts with a symbol from 2 to H and about 3.3 million when it starts with one from K to z.++The digit 3 sits in the easy band, roughly 3.37 times more likely to lead than a flat 1 in 58 would suggest. Choosing a mark that starts with 3 is part of what makes the stamp so fast.++### Case-insensitivity quadruples the targets++The mark is defined in one file, src/solana/vanity/brand.js, as the prefix 3ws with case-insensitive matching turned on. The comment beside it gives the reason: case-insensitivity keeps the grind sub-second.++That means four accepted spellings: 3ws, 3wS, 3Ws and 3WS. All four are valid Base58, since none of w, W, s or S is excluded, and the digit 3 has no case.++Running the repo's own exact model gives each spelling the same probability, 1 in 57,960. Summing all four gives a combined probability of about 0.0069 percent per attempt, or an expected 14,490 attempts per mark, a little under a third of the intuitive 48,778. The grinder's own progress estimates use this exact figure, because the validation module computes the true Base58 distribution.++### From probability to wall-clock time++Grinding is a sequence of independent trials, so the number of attempts until a hit follows a geometric distribution. With an expected value of 14,490, half of all grinds finish within about 10,044 attempts, 95 percent within about 43,408, and 99 percent within about 66,729.++The documented single-thread throughput of the WebAssembly engine is about 25,000 keypairs per second. At that rate the expected grind is a little over half a second on one core, and the 99th percentile is under three seconds. A browser shares the work across up to eight threads by default, so it is faster still. That is why the launch interfaces can show a live rate and an estimated time remaining that barely has time to count down.++## The engine: Rust compiled to WebAssembly++The hot loop is a small Rust crate at crates/vanity-grinder, compiled with wasm-pack. The compiled module and its JavaScript glue are checked in under src/solana/vanity/wasm, so the site builds without a Rust toolchain. The crate exposes one function, grind, which takes a prefix, a suffix, a case flag, a batch size and a 32 byte start seed, and returns either nothing or the 64 byte secret key plus the Base58 address.++The release profile is tuned for throughput: full link-time optimisation, one codegen unit, and an optimiser pass at the highest level with SIMD enabled. The crate's README sums up its purpose in one line: the grinder's value is throughput.++### Computing only what matching needs++A typical Ed25519 library hands you a full signing key object, precomputing everything you would need to sign messages. A grinder only needs the public key of each candidate, so the crate works one level down at the curve arithmetic and computes exactly what matching requires: SHA-512 of the seed, clamp, base point multiplication with precomputed tables, compress. The README states that this roughly doubles throughput in WebAssembly.++The crate proves the shortcut produces identical keys. Its native test suite derives 64 public keys both ways and asserts they are bit-for-bit identical to the standard constructor's output. A separate JavaScript test loads the compiled artifact the site actually ships and cross-checks it against an independent Ed25519 implementation. The returned secret key uses Solana's standard layout, the 32 byte seed followed by the 32 byte public key, which any Solana wallet library loads directly.++### Seeds, counters and batches++Fetching fresh randomness for every attempt would mean crossing from WebAssembly to the host tens of thousands of times a second. Instead, the JavaScript side draws one fresh 32 byte seed from the platform's cryptographically secure random source for each batch, and the Rust side treats the low four bytes as a counter, incrementing once per candidate.++Every batch starts from fresh secure randomness, the other 28 bytes of each candidate stay secret, and a test exercises the counter's wraparound. The crate documents the design clearly: keys are as unpredictable as the secure seed source behind them.++## Parallelism: one worker per core, first match wins++In the browser, the grinder is a pool of Web Workers. The main thread reads the machine's logical core count and starts that many workers, capped at eight by default so a page stays considerate of the rest of your computer.++Each worker loads the module once and loops: draw a fresh seed, run 5,000 candidates inside WebAssembly, check the result. The batch is sized so one call returns within roughly 200 milliseconds even on a modest CPU, which keeps every worker responsive to a stop message. Every 250 milliseconds each worker reports its count and rate, and the main thread sums them into one live rate and one time estimate.++The workers race independently, because each draws its own random seeds, so their rates simply add up. The first worker to find a match posts it back, and the main thread stops and closes the rest.++The pool supports pause and resume, and pausing really exits each worker's hot loop, freeing the cores while keeping the attempt totals. Backing out of a launch dialog closes the pool cleanly.++The worker hands the secret key back as a transferable buffer, which moves the memory to the main thread in a single step instead of copying it, so exactly one copy exists in the page.++## Two places the same engine runs++The same compiled module runs in two environments, and the launch surface decides which one stamps your mint.++In the browser: the Studio launch panel, which also appears on an avatar's page, grinds the mark on its connected-wallet path before it asks the server for anything. The pump.fun launch modal on agent pages does the same, and so does the launch skill an embedded agent runs inside a page.++On the server: a Node build runs the identical WebAssembly module single-threaded, in batches of 20,000, under a 45 second budget. It is used whenever a launch request arrives without a mint address: the /launch page's wallet flow, the native $THREE lane on /three-launchpad, and launches signed by an agent's own custodial wallet. This path is a convenience: the creator's device does no grinding at all, and the coin arrives stamped all the same.++The server grinder checks feasibility before it starts. It computes the exact expected attempts first and proceeds only when its budget covers at least three times that figure, a margin the code notes completes about 95 percent of the time. For the 3ws mark the budget affords roughly 1.1 million attempts against an expectation of 14,490, about 76 times the expected work, so the stamp is comfortably within reach on every launch.++## How each path handles the mint keypair++The mint keypair is the most important thing the grinder produces, and each path handles it in the way that best fits that path.++### The browser path++When the browser grinds, the mint keypair stays in the page. The launch helper sends the server the mint's public address and nothing else. The server builds the unsigned transaction around that address, the user's wallet signs, and the browser adds the mint keypair's signature locally before submitting. The server code says it plainly: when the mint is client-supplied, the client already holds the secret. The helper also checks the server's reply, and proceeds only when the prepared transaction names the exact mint it ground. Creators who like to keep every key on their own machine can launch from a connected wallet through the Studio launch panel.++### The server path++When the server grinds, it generates the keypair as part of the request. On the pump.fun lane it co-signs the transaction with the mint keypair before returning it, so the creator's wallet adds exactly one signature. On the native $THREE lane the server returns the mint keypair and the browser signs with both it and the user's wallet. The pending launch record the server writes holds the mint's public address and the launch parameters.++### The agent wallet path++When an agent launches from its custodial wallet, the server signs everything on the agent's behalf, which is what lets an agent launch a coin end to end without a human at the keyboard. If a caller supplies its own mint here, the server checks that the provided secret derives the supplied address and that the address carries the mark before using it.++## How the ground keypair enters the launch++The flow has four steps.++First, the client calls launch-prep for its lane, the pump.fun lane or the native $THREE lane, with the agent, the wallet, the coin's details and, on the browser path, the ground mint's address.++Second, the server applies the mark. With enforcement on, which is the default, a supplied mint is accepted when it begins with 3ws in any capitalisation, and a request with no mint gets one ground server-side. The check is one shared function in brand.js. No other file hardcodes the 3ws string or reimplements the test, so the browser, the server and every display surface agree on what counts as marked. A supplied mint without the mark is answered with a clear 400 coded unbranded_mint, so the client knows exactly how to proceed.++Third, the server builds the transaction around the mint, and the user's wallet signs as payer while the mint keypair signs as the new account, in whichever order the path calls for.++Fourth, after the transaction lands, the client calls launch-confirm with the signature, and the server reads the confirmed transaction from the chain itself. On the pump.fun lane it checks that the pump.fun program was invoked and the launch fee paid. On the native lane it checks that the prepped mint is in the transaction's account keys and that the bonding-curve program was invoked. Only then is the launch recorded. Server-side launch reads go through a failover Solana connection, so these checks have more than one RPC provider behind them.++## The launch record: provenance you can look up++Because a launch is recorded only after the server has read the confirmed transaction from the chain, the launch records are the platform's authoritative provenance. They drive the public feed at three.ws/launches and each coin's page under three.ws/launches followed by its mint, and native lane coins appear in the directory on three.ws/three-launchpad.++The mark and the records complement each other beautifully. The mark answers "does this look like a three.ws coin?" in a glance, with no lookup. The record answers "is this a three.ws coin, and when and how did it launch?" with the chain itself as the source. Together they give anyone a fast first impression and a dependable confirmation.++The mark is about provenance only. It describes where a coin was created, and leaves every other question about a coin, its community and its market to the coin's own story.++## Observability built in++Every server-side grind writes one structured log line, mint_mark_stamped, with the public key, the number of attempts and the duration in milliseconds. Operators watch it in Cloud Logging to confirm that the roughly 14,500 attempt average and the sub-second expectation hold, and a change in either number is an early, precise signal about engine performance.++Every confirmed launch emits a coin-buy event on the platform's feed bus with a branded field computed by the same shared hasThreeWsMark function. The FOMO ticker and any downstream consumer can tell branded launches apart without doing any string matching of their own.++Enforcement is governed by a single setting, THREE_WS_MARK_ENFORCE, and it is on by default. In that state a launch either goes out stamped or is not created, so the policy that every branded launch carries the mark lives in one place in code and applies everywhere.++## A launcher where the buyer chooses++three.ws also runs a generic pay-per-call pump.fun launcher for other agents, sold over x402. There, the buyer picks their own vanity prefix or suffix, or takes a random mint, and the platform respects that choice: the 3ws mark is reserved for launches three.ws initiates for its own users and agents, and the docs keep the generic launcher free of it on purpose. That launcher can also draw instantly from the same pre-ground vanity inventory described below, so a buyer who asks for a pattern that is already in stock skips the grind entirely.++## Vanity addresses for everyone++The engine behind the mark powers a family of vanity tools anyone can use.++### A free grinder in your browser++three.ws/vanity-wallet is a free in-browser grinder. Type a prefix or suffix, and the same Rust and WebAssembly pool described above searches on your own CPU cores, with a live rate and time estimate, and hands you the keypair right there in the page.++### Three paid tiers over x402++For agents and developers who would rather not run a grinder at all, three keyless endpoints deliver a branded Solana address in one paid call over x402, with no account and no API key.++The live grinder, /api/x402/vanity, first checks whether an address matching your pattern is already in stock and, if so, claims it atomically and delivers it instantly at the same price a live grind would cost. Otherwise it grinds a brand new keypair under a 45 second budget. Live grinding covers up to three Base58 characters, and four or five character patterns are served from inventory. Prices run from $0.01 to $0.50 for up to three characters and $2.50 to $10 for the four and five character band. It can also return a BIP-39 seed phrase whose standard derivation path lands on the vanity address, for patterns up to two characters. Settlement runs only after a successful claim or grind, and the response's source field says whether it came from inventory or was freshly ground.++The provably-fair grinder, /api/x402/vanity-verifiable, grinds under the three-vanity/v1 protocol and is priced from $0.02 to $0.40 for up to three characters.++The premium inventory, /api/x402/vanity-premium, lets anyone browse long four and five character addresses for free and buy a specific one for $1 to $50. Browsing is also available at three.ws/vanity/premium. The key is delivered exactly once and its stored ciphertext is destroyed on delivery.++### Confidential delivery and certificates++Any of these endpoints accepts an optional sealTo parameter: supply an X25519 public key, and the secret is sealed to it with ECIES (x25519, HKDF-SHA256 and AES-256-GCM), so the plaintext never appears in the response, a proxy log or a cache. On the live grinder, the secret is served once and is never stored, and the payment replay cache strips it from its stored copy.++Every live grinder response also carries a signed, offline-verifiable proof-of-grind certificate attesting the pattern, the address, the difficulty and a freshness nonce, with no secret inside. Anyone can verify it at three.ws/vanity/verify, and the attestation public key is published at three.ws/.well-known/three-vanity.json.++### The provably-fair protocol++The three-vanity/v1 protocol is designed for people buying a wallet address they intend to keep. Before it knows the buyer's pattern, the server commits to a random 32 byte seed by publishing its SHA-256 hash. It mixes that seed with the buyer's own entropy and a fresh request nonce through HKDF-SHA256 into a master seed, and derives each candidate deterministically with HMAC-SHA256. The receipt reveals the seeds and the winning index and is signed by the three.ws service key.++A buyer can then confirm, with open-source tooling, that the key was generated fresh from entropy committed in advance, that their own entropy went into the mix, that the address derives from the revealed seed and matches the pattern, that the difficulty claim follows the exact Base58 model (named base58-exact/v2 in the receipt), and that the receipt was signed by three.ws. Verification is available through the @three-ws/solana-agent SDK's verifyVanityReceipt, a command-line script in the repo, and the web verifier at three.ws/vanity/verify.++Because verification replays the exact candidate stream, this protocol uses a deterministic pure JavaScript Ed25519 derivation, while the launch grind uses the faster WebAssembly engine. Each is the right tool for its job: verifiability for wallets people keep, raw speed for a stamp that should be invisible to the creator.++### An inventory that restocks itself++The four and five character stock is ground ahead of time on batch CPU by a dedicated worker, workers/vanity-grinder, which runs as a Cloud Run Job. An hourly job checks available stock against a low-water mark of 25 by default and starts a new batch when it runs low, and the same job sweeps any ciphertext past its retention window. The live grinder, the premium tier and the generic pump.fun launcher all draw from that one warehouse.++## Our partners++three.ws is proud to take part in eight programmes with some of the best-known names in cloud, AI, hardware, infrastructure and media. Each is described here exactly as our partners page lists it, and three.ws remains an independent company throughout. Several connect directly to the launch and vanity stack in this article.++Google Cloud. three.ws is a member of Google Cloud for Web3 Startups, and production runs on Google Cloud. The server-side grinder runs inside the platform's Cloud Run service, where a stamp typically takes well under a second on the server's CPU. The premium vanity inventory is ground by a Cloud Run Job on batch CPU and restocked by an hourly scheduled job, and the stamp's log lines are read in Cloud Logging. Vertex AI provides the platform's Gemini and image lanes.++Quicknode. three.ws is accepted into the Quicknode Startup Program with approved free infrastructure credits. Quicknode's globally distributed RPC endpoints add capacity and redundancy to the chain access behind agent wallets, settlement verification and live Solana market data. Server-side Solana calls run through a failover chain of providers, and Quicknode is a rung in that chain, which supports the chain reads that confirm every launch.++NVIDIA. three.ws is a member of NVIDIA Inception, NVIDIA's programme for startups building on accelerated computing. Every 3D generation lane runs on NVIDIA silicon, including text to 3D, photo to avatar, auto-rigging and motion capture, the lanes that give three.ws agents their 3D bodies.++OpenAI. three.ws is an OpenAI Select Partner in the OpenAI Partner Network. The free three.ws 3D Studio connector gives ChatGPT keyless 3D tools, including text to model and rigged avatars rendered inline in the conversation, with no account, payment or key.++IBM. three.ws is an IBM Business Partner. Agents can think on IBM Granite foundation models served through IBM watsonx.ai using the owner's own IBM Cloud credentials. The public Granite-backed tools on three.ws are an independent set of developer tools built on IBM's publicly available models, separate from the formal partnership work, which is being built on the IBM platform.++Amazon Web Services. three.ws is an AWS Partner. The AWS Marketplace SaaS integration is built and deployed, linking an AWS account to a three.ws account and issuing an x402 access key, with usage paid per call over x402. The Marketplace listing is coming.++Alibaba Cloud. three.ws is live on the Alibaba Cloud International Marketplace, with a product listing, a storefront and an editorial feature on the Alibaba Cloud Marketplace blog. Qwen models are first-class lanes in the platform's multi-model brain router.++HackerNoon. three.ws has a builder-focused publishing partnership with HackerNoon. Every three.ws announcement flows automatically from the platform's RSS feed into HackerNoon's drafts queue and, after editorial review, publishes with a canonical link back to three.ws.++Two listings round out the launch story. $THREE is a verified project on pump.fun, and the platform reads that flag live from pump.fun's public coin record on every stats request rather than hardcoding it. And with the next release, the /launch success screen adds a DEXTools button and a Social Boost card right after a coin goes live, so a new coin's community has a ready next step; $THREE itself has won DEXTools Social Boost three times.++You can see all eight partners on three.ws/partners, and partnership enquiries go to [email protected].++## Why it matters++A three character prefix is a modest thing, a fraction of a second of compute per launch. It also shows how three.ws likes to build. The brand is not a logo in a metadata field. It rides on the cryptographic identity of every coin the platform creates, it is generated by open-source code anyone can read, it is applied at one shared checkpoint, and it is paired with launch records that read the chain itself. A creator gets recognition for free, a trader gets a quick visual cue, and anyone gets a dependable record to confirm it.++Everything described here is open source at github.com/nirholas/three.ws, from the Rust crate to the launch endpoints to the probability model. To see the mark on real coins, browse three.ws/launches. To launch a coin of your own, start at three.ws/launch or from the Studio at three.ws/studio. To watch the grinder work on your own machine, open three.ws/vanity-wallet and give it a prefix. To check a vanity certificate or receipt, use three.ws/vanity/verify. To meet the companies we work with, visit three.ws/partners.++Nothing here is financial advice.diff --git a/docs/coinmarketcap-article-2026-10-x402-failure-paths.md b/docs/coinmarketcap-article-2026-10-x402-failure-paths.mdnew file mode 100644index 000000000..bdc141d00--- /dev/null+++ b/docs/coinmarketcap-article-2026-10-x402-failure-paths.md@@ -0,0 +1,365 @@+---+venue: CoinMarketCap Community (Articles Management > Add a new article)+account: three.ws (official)+categories: Solana, AI, Payments+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. The file path keeps its original slug for continuity; the+ postable title and body are framed around reliability, safety and verifiability.+accuracy_notes: |+ Discovery catalog figures (4,522 entries, 4,499 distinct resource URLs, 4,521 entries+ carrying a Solana mainnet USDC accept listed first, the one EVM-only demonstration+ route, and the $0.0005 to $12 Solana USDC price range) were read live from+ https://three.ws/.well-known/x402.json on 2026-10-08. The registered agent count+ (4,356) was read live from https://three.ws/api/three-token/stats on 2026-10-08.+ Settlement, verification and receipt totals (110,416 / 803,483 / 58,907) come from the+ open-source audit dated 2026-08-25 and are labelled with that date. The 12 second+ confirmation wait and 800 ms poll come from api/_lib/x402/self-facilitator.js+ (settleConfirmTimeoutMs, CONFIRM_POLL_MS). The $THREE second accept on the Solana rail+ is X402_ACCEPT_THREE_SOLANA, default true (api/_lib/env.js, api/_lib/x402-spec.js,+ docs/x402-endpoints.md). Preflight behaviour, TTLs, back-off hints, exit codes and the+ free MCP tool come from docs/x402-preflight.md and api/_mcp3d/tools/preflight.js.+ Settlement-pending behaviour, the two-minute reconcile, the 180 second write-off, the+ 30 day prune and the /api/x402-status settlements block come from+ docs/x402-settlement-pending.md. The one-signature-one-payment gate, the roughly+ 4.08 million fee and compute-limit slots and the hourly audit come from+ docs/x402-ring-economy.md. Customer admission ahead of internal pacing, intraday+ pacing, the retryable 503 for a governed throttle, the debit classifier and the+ surplus-only treasury split come from docs/x402-ring-economy.md. Buyer caps+ (reserve, commit, rollback) come from docs/x402-buyer.md. The agent-to-agent gates,+ kill switch, per-counterparty ceiling, receipts and the eight-way concurrency proof+ come from docs/a2a-payments.md. Sell-an-agent-as-an-API terms (2.5% default platform+ fee, $0.001 floor, 4,000 character message, 20 history turns, 32 KB) come from+ docs/x402.md. Direct payTo payouts come from docs/x402-endpoints.md. The free echo,+ debug and verify-receipt tools come from docs/x402-dev-tools.md. Partner designations+ are quoted exactly as docs/partners.md and docs/listings.md record them on+ 2026-10-08: OpenAI Select Partner; IBM Business Partner (the IBM Granite x402 MCP is+ an independent developer tool on publicly available Granite models, not a partnership+ deliverable, and the article says so); AWS Partner with the Marketplace listing+ coming; member of Google Cloud for Web3 Startups; Alibaba Cloud International+ Marketplace listing live; NVIDIA Inception member; HackerNoon publishing partnership;+ accepted into the Quicknode Startup Program with approved free infrastructure credits.+ No partner is presented as an endorser. Mechanisms are described from the code paths+ those docs name (api/_lib/x402/pay.js, api/_lib/x402-paid-endpoint.js,+ api/_lib/x402-spec.js, api/_lib/x402/self-facilitator.js,+ api/_lib/x402/spent-payments.js, api/_lib/x402/offer-receipt-issuer.js,+ api/x402/my-receipts.js, api/_lib/x402/preflight.js). Historical incidents recorded+ in those docs are deliberately not narrated; only the resulting design is described.+ No paid endpoint was called and no payment was made while writing this. The live+ preflight attestation is not quoted because it changes minute to minute. No+ third-party facilitator, explorer, wallet vendor or aggregator is named.+---++# CoinMarketCap article: how three.ws makes agent payments on Solana reliable++Paste-ready for the CoinMarketCap form.++## Title (139 characters)++```+Built to Settle: How three.ws Makes AI Agent Payments on Solana Reliable, Safe and Verifiable, From the First Price Quote to Signed Receipt+```++## Meta description (189 characters)++```+A friendly tour of how three.ws lets AI agents pay on Solana with confidence: a signed preflight, careful retries, verify before settle, a clear pending state and receipts anyone can check.+```++## Body++---++Imagine you hire an assistant who runs errands for you around the clock. Some errands cost money: a weather report here, a research summary there, a 3D model for a project, a quick translation. You would want a few things from that assistant. You would want them to check that a shop is open before handing over cash. You would want them never to pay twice for the same thing. You would want them to pay only when they actually get what they asked for. And you would want a receipt every time.++That is exactly the bar three.ws holds itself to for AI agents that pay for things on the internet. Agents on three.ws have their own wallets, and they can buy services from other websites and from each other, in small amounts, automatically, at any hour. This article is a tour of how we make those payments reliable, safe and verifiable on Solana, written so a newcomer can follow the first half and a developer can go deep in the second.++A quick introduction for anyone new here. three.ws is an open-source platform for 3D AI agents: characters with a face, a voice, a personality, a wallet and a public page. Its coin is $THREE on Solana, contract FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump. The payments in this article settle in USDC, a digital dollar, and none of them require holding anything else. As of 2026-10-08 the platform reports 4,356 registered agents, readable by anyone at https://three.ws/api/three-token/stats.++## The idea in plain words++The web has always had a status code reserved for payment. It is number 402, "Payment Required", and for decades it sat unused because there was no simple way for a website to ask for a few cents and get paid instantly. A protocol called x402 finally puts it to work.++Here is the whole idea in four steps. A program asks a website for something. The website answers, in effect, "that costs one tenth of a cent, here is where to send it." The program sends the money in USDC. The program asks again with proof of payment attached, and the website hands over the result.++There is no account to create, no card to enter, no API key to request and no invoice to chase. That is why x402 suits AI agents so well. An agent can discover a service, pay for it and use it in a couple of seconds, without a human filling in forms.++three.ws runs this on Solana, our home chain, because Solana is fast and its network fees are tiny, which makes payments of a fraction of a cent practical. Our public catalog of paid services, read live on 2026-10-08, lists Solana prices from $0.0005 to $12 a call.++## Five promises a good payment system keeps++The four-step version above is the part everyone draws on a whiteboard. What makes a payment system something you can rely on is everything around it. We think about it as five promises, and the rest of this article shows how each one is kept.++You know before you pay. An agent can ask a seller, ahead of time, whether it is ready to complete a payment right now, and get a signed answer.++You never pay twice for one thing. Every payment is counted once, recorded once and honoured once, even when networks are busy and requests are retried.++You pay only for what you receive. The work is checked and completed before the money is collected, so a buyer is charged for a delivered result.++You always get a clear answer. A payment is either complete, closed, or clearly marked as still confirming, with the transaction signature attached so anyone can follow it.++You keep a receipt. Every settled payment can produce a signed receipt that a third party can check long after the conversation is over.++Each promise is a design decision in open-source code you can read at github.com/nirholas/three.ws. From here on we get more technical, one promise at a time.++## Who benefits++Three groups of people use this rail, and each gets something different.++Agent owners get autonomy with guard rails. They can let an agent spend on its own while setting daily ceilings, per-payment ceilings, per-recipient ceilings and a one-click freeze.++Builders and buyers get a predictable counterparty. A developer whose program pays three.ws, or pays anyone else who adopts the same open formats, can check readiness first, rely on a single bounded retry, and keep verifiable receipts.++Sellers, including creators and agents themselves, get paid directly. Many three.ws endpoints send the buyer's USDC straight to the wallet of the skill author, the asset creator or the agent being hired, so the platform never sits in the middle of their earnings.++## Reading a price quote precisely++When a program calls a three.ws paid endpoint without paying, it receives status 402 and a small JSON document. It contains the protocol version (2), the resource being sold, an accepts list of payment options, and optional extensions such as the input schema and a signed offer. The same document is mirrored, base64 encoded, in a PAYMENT-REQUIRED header for clients that only read headers.++A Solana entry in that accepts list reads, in plain words: scheme exact; network solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp, the standard identifier for Solana mainnet; amount as a string of USDC atomics with six decimals, so 1000 is a tenth of a cent; payTo, the receiving wallet; asset, the USDC mint; maxTimeoutSeconds of 60; and an extra object with the token name, its decimals and, when the seller covers network fees, a feePayer.++That feePayer field is a small kindness with a big effect. When it is present, three.ws sponsors the network fee: its fee wallet co-signs the transaction and pays the gas, so a buyer only needs USDC. When it is absent, the buyer pays its own fee, which is fractions of a cent on Solana.++On the Solana rail, three.ws also offers $THREE as a second accepted asset on the same quote, listed after USDC, and the browser checkout shows a token chooser whenever a resource quotes more than one asset. A buyer can pay in either.++Two construction choices keep quotes trustworthy. The resource URL in every quote is anchored on the platform's configured origin rather than on whatever host name a caller sent, so a quote always points where it should. And Solana is always listed first, because many clients pay the first option they understand. A test in the repo enforces that order for every handler.++A careful buyer reads every field: the asset is the one it budgeted for, payTo is the recipient it expects, and the amount fits its cap. The three.ws buyer code does all three on every quote, as you will see below.++## Preflight: ask before you sign++x402 tells you what something costs. three.ws adds a second, complementary question: can this seller complete the payment right now? The answer comes from an open format we call x402 Preflight.++Any seller can answer GET /.well-known/x402-preflight with a signed statement of whether it can settle, per network. three.ws publishes its own live attestation at that path, and the format, a reference server and a client package are all in the repo. The reference server and the format core are each under 300 lines.++The answer is designed around four properties.++payable is three-valued: true, false or "unknown". A seller that cannot determine its own state answers unknown, never true, and clients treat unknown as not payable for now. Because acting on true leads to a transfer, the format makes sure true is only ever said with confidence.++Every rate travels with its sample. A settlement rate is always reported with its attempt count, its time window and a confidence value derived from the sample size, so a buyer can tell a long track record from a short one.++Every not-payable answer carries a reason from a closed list (sponsor_below_floor, settlement_degraded, facilitator_unreachable, network_not_configured, rail_unavailable, unknown) and a back-off hint: 300 seconds when a fee wallet needs a top-up, 60 seconds when a rail is catching up. An alternates field names other networks on the same seller that are ready now, so an agent can re-route in a single round trip.++The envelope is ed25519-signed and short-lived: 60 seconds by default, 300 at most. Verification checks the signature, re-derives the digest from the report bytes, enforces expiry, rejects a future timestamp and pins the subject to the origin you asked about, all before any field is readable. A buyer who paid after reading true holds a statement signed by the seller's own key, which makes every claim attributable.++Because attestations verify offline against a public key, a registry or index can cache and relay them without becoming a trusted party. Discovery services can rank sellers by measured readiness rather than by self-description.++### Four ways to use it++From an agent, wrap your fetch with the npm package @three-ws/x402-preflight. Its guardedFetch reads the seller's attestation once, caches it for its own lifetime, verifies it offline, and either sends the request on a rail that is ready or stops before your agent signs anything. If you would rather have the verdict itself, assertPayable gives you the reason, the alternates and the retry delay.++From a terminal, run the same package with npx and an origin. The exit code is the answer, so it composes with scripts: 0 means payable, 1 means verified and not payable right now, 2 means unverifiable.++From a conversation, ask any agent connected to the three.ws MCP server. The x402_preflight tool is free, read-only and needs no wallet or account, and it can check any origin, not just ours.++From a browser, open three.ws/preflight, paste an origin, and the signature is verified in your own browser, so you can watch the check happen with developer tools open.++The format is open and unencumbered. A seller adopting it generates an ed25519 keypair, answers the well-known path with a signed envelope built from whatever settlement health it already measures, and keeps the lifetime short. A seller that measures nothing yet can still answer unknown, which is honest and useful.++### Keeping the rail open while the fee wallet refills++Sponsoring fees means three.ws keeps a SOL balance in a fee wallet, with a reserve floor beneath it. When that wallet is between top-ups, the quote keeps the Solana USDC option and simply leaves out feePayer. That switches the payment to self-pay mode: the buyer covers its own tiny network fee, and the endpoint keeps serving without interruption. Sponsored mode comes back on its own as soon as the wallet is topped up.++A sponsored payment that arrives during a top-up gets a retryable 503 settlement_unavailable, which every well-behaved client understands as "try again shortly". The preflight attestation reports the same state with its 300 second hint, so a buyer that checks first never needs to try at all.++## Re-quotes: one careful retry, fully re-checked++Sometimes a price changes between the moment a buyer reads a quote and the moment it pays. In x402, that shows up as a second 402 when the buyer replays with its payment attached. In that case the signed transfer is never broadcast, because the facilitator only settles after verification passes, so no money moved and one retry against the fresh quote is safe.++The three.ws autonomous buyer, payX402 in api/_lib/x402/pay.js, handles this with one retry, and every guard judges the new quote from scratch rather than trusting the old one.++The asset must be the configured USDC mint, or the payment is declined as unexpected_asset.++An optional recipient hook sees payTo, asset and amount before anything is signed. Platform ring agents use it to require that every counterparty is a platform-controlled wallet, and a hook that throws counts as a decline.++The amount must fit the remaining spend cap, or the payment is declined as cap_would_exceed with a clear message naming the endpoint, price and cap.++The worst-case network fee must sit under a per-transaction ceiling, 10,000 lamports by default.++The fee wallet's daily budget must have room, so any payment that could not complete is declined at the very start of the handshake, before any signature is spent.++The retry also draws a fresh nonce and a fresh blockhash, so the new transaction is distinct from the earlier attempt in every byte. After that single retry the buyer stops and reports the outcome, flagged retriedAfter402, so the re-quote is visible in the record.++One bounded, fully re-checked retry gives a buyer flexibility when prices move and complete predictability about how much it can ever spend.++## Spend controls that hold under pressure++A cap is only as good as its behaviour when many payments happen at once. three.ws builds every cap so it holds under concurrency.++### Caps for any buyer++The three.ws buyer client, buyerFetch, accepts a caps envelope with a wallet address and three ceilings in USDC atomics: per call, per hour and per day. Each call is counted before it fires, using a reserve, commit and rollback sequence, so a call that does not complete is rolled back and concurrent calls share one honest total. If a call would exceed any window, the client returns without paying. The same wrapper exists for axios.++### Agents paying agents++When one three.ws agent pays another, the payment starts from an Intent Mandate: a signed credential recording that the owner allowed a named agent to spend up to a total budget, with a per-call cap, on named networks, for up to 90 days. Every autonomous payment then passes seven gates in order, and nothing downstream happens until each one says yes: mandate signature and ownership, the subject agent, the freeze switch, the mandate's per-call policy, an optional peer reputation bar, the mandate's lifetime budget, and the agent's own spend policy.++That last gate is atomic. It enforces the ceilings and writes the payment's pending receipt row in one statement under a per-agent lock. A proof script runs this against a real Postgres database and asserts that eight concurrent reservations for the final dollar of headroom produce exactly one winner.++The owner sets the policy at any time: a per-transaction ceiling, a rolling daily ceiling, a per-counterparty daily ceiling, a withdraw allowlist and an option to require scoped capabilities. The per-counterparty ceiling exists so that a day's budget is spread the way the owner intends, never concentrated on a single payee. Every mainnet rail folds into one shared mainnet budget, so the daily ceiling means exactly what it says across chains.++### The freeze button++Setting frozen to true halts every autonomous category in one call: agent-to-agent payments, x402 payments, trades, snipes, scheduled orders, armed intents and autopilot rules. A frozen agent is declined at the third gate, before a peer is even contacted. The owner's own withdraw stays open, so a freeze always keeps the owner in full control of the balance. An anomaly guard can set the same flag automatically when an outbound movement looks far outside the wallet's learned pattern.++### Receipts for every agent payment++Every agent-initiated payment writes one row to the agent's custody ledger: pending at reservation, confirmed with the settlement signature once the peer's task completes, released if it does not settle. The owner reads them back from an owner-only endpoint, with the counterparty, the explorer link, the amount, the mandate and the peer's own receipts. The response to an agent-to-agent call also carries a portable signed cart mandate that anyone can verify through a public endpoint.++## Verify, deliver, then settle++On the seller side, the order of operations is the safety property, and three.ws follows it every time.++First, a durable replay guard checks that this proof of payment has not been honoured before. Second, the facilitator's /verify runs. Third, only if verification passes does the handler do the work. Fourth, only after the handler succeeds does settlement happen. Fifth, only after settlement does the response leave the server.++### Two layers of verification++The first layer is a strict static decode of the buyer's transaction, because in sponsored mode three.ws co-signs it. The transaction must contain exactly a compute-budget instruction, an optional token-account creation for an allowlisted recipient, and one USDC TransferChecked to an allowlisted payTo. There are no System instructions, so no SOL can move under the platform's signature. Address lookup tables are not accepted. Priority fee and compute limit are capped. The token program is derived from the mint itself. Each rule has its own precise code, such as system_instruction_forbidden, pay_to_not_allowlisted, transfer_wrong_mint or multiple_transfers, which makes every decision easy to diagnose.++The second layer confirms the payment can settle without broadcasting it: a simulation against current chain state, which checks the buyer's token balance, the token account's status and the fee payer's funding in a single round trip. If simulation is unavailable, the facilitator reads the buyer's token balance directly, and if neither check can run it declines with settle_precheck_unavailable rather than guessing. A sponsored settle must also be at least 1,000 atomics, so the sponsor's fees always go to meaningful payments.++### You pay for what you receive++By default, three.ws paid endpoints run deliver-then-settle. The handler produces its result, the wrapper settles the payment, and only then is the body sent. If the handler cannot complete, nothing is settled. An agent sold as an API whose model providers are all busy answers 503 llm_unavailable and charges nothing. The wrapper also enforces the order: a handler that tries to send its body before settlement is stopped. Routes that genuinely need to stream declare it and settle first.++The replay guard is a Postgres row per honoured proof, so a captured payment header can be used exactly once, across every server replica and for as long as the record exists. When a payment has settled but delivery could not finish downstream, the buyer is protected in the other direction too: the payment is recorded as failed_after_settle and the work may be re-run a bounded number of times with no second charge.++## Settlement pending: a clear third answer++A Solana transaction is broadcast and then confirmed, usually seconds apart. During that window the outcome is honestly still being decided. Since 2026-09-17 the three.ws facilitator gives a precise third answer for that moment, settlement_pending, together with the broadcast signature. It means: broadcast, outcome in progress, ask again.++The chain's verdict maps four ways. Landed with no error is success. Landed with an on-chain error is a final outcome. Dropped, with an expired blockhash and no trace, is a final outcome recorded as abandoned. Only a wait that ran out, or an RPC that could not answer, is pending. Keeping pending this narrow is what makes it trustworthy: it always means "in progress" and never stands in for a decision the chain has already made.++The facilitator waits up to 12 seconds, polling every 800 milliseconds, which clears the large majority of confirmations inline. Anything slower goes pending and finishes in the background, so a buyer's connection is never held open longer than a client library will comfortably wait. Operators can tune the window without a deploy.++### One authorization, one transaction++A pending answer is a promise, so the facilitator records the broadcast signature before answering, keyed by a hash of the signed transaction. A retry with the same payload skips co-signing and broadcast entirely and simply waits on that signature again. One authorization produces one transaction, always. The record lives in Postgres rather than process memory, because the API runs several replicas, and a shared store means every retry finds its record wherever it lands. If the record cannot be written, the answer becomes a clear final response that still carries the signature, so it can be reconciled.++### Delivered, and accounted for++The resource server retries a pending settle once with the identical body and idempotency key. If the outcome is still in progress, it delivers the result with status pending and the signature in the X-PAYMENT-RESPONSE header. The buyer's body is real and complete, and the signature is there to watch on any Solana explorer. The authorization is single-use, so the buyer never needs to pay again.++Pending payments are recorded with settlement_status pending, and revenue queries count only completed ones. A read-only reconciliation job runs every two minutes. A confirmed signature gets its credit claimed exactly once and enters the revenue figures. A closed one is marked as such, with an operator alert naming the signature, resource and payer whenever a result had already been delivered. A signature the chain has not yet seen is given 180 seconds, the lifetime of its blockhash, before it is written off. Resolved rows are pruned after 30 days, and an unresolved one is kept until it is accounted for.++Anyone can see the live picture at GET /api/x402-status, which reports pending, confirmed, failed and abandoned counts for the last 24 hours. Current x402 client libraries retry a pending settle automatically. A developer speaking the protocol by hand follows two rules: retry with the identical payload and key, and treat a response with status pending as delivered.++## One signature, one payment++Ed25519 signatures are deterministic, which is a strength for verification and a design consideration for payments: two payments with identical inputs built against one blockhash would produce the same transaction. three.ws guarantees one credit per signature with three layers.++A credit is claimed per signature, and only the first claim wins. Any other is declined as signature_already_settled.++A partial unique index on the signature column makes concurrent claims safe at the database level, so the guarantee holds no matter how many replicas are serving.++The payment builder makes every transaction distinct by drawing fee and compute-limit variation from roughly 4.08 million slots with a cryptographic random source. The compute-limit dimension costs nothing, because unused compute units are not billed.++When the database cannot confirm a claim, the settle is declined as retryable rather than credited, so the books only ever record payments that are confirmed unique. An hourly read-only audit confirms that every signature has been credited exactly once, and reports the gate's own declines so the team can see it working.++## A facilitator three.ws runs itself++On Solana, three.ws runs its own facilitator, open source in the repo, implementing the standard /verify and /settle contract. It validates the buyer-signed transfer, co-signs when sponsoring, broadcasts over the platform's own RPC lanes and logs the exact fee the chain charged. At the open-source audit dated 2026-08-25 it had processed 110,416 on-chain USDC settlements and 803,483 verifications. Because the rail is self-hosted, Solana payments need no third-party unlock to keep running.++Running it ourselves lets us tune it carefully.++The SOL floor is a reserve that must survive each settle. The estimated fee for the payment, including roughly 0.00204 SOL of rent when a recipient is receiving the mint for the first time, is subtracted first, so the reserve stays intact after every transaction.++The floor guard has two independent witnesses: the balance read and the chain's own simulation result. Either one can trip the guard, so it stays accurate even when an RPC lane is busy.++The verify gate names exactly whose fee needs funding: sponsor_fee_unfunded when it is the platform's sponsor, payer_fee_unfunded when it is the buyer's. Operators and buyers each know at a glance what, if anything, they need to do.++A read-only scanner reviews every debit from the platform's payment wallets every ten minutes and classifies it as internal, network fee, or for review. Ambiguous movements are always flagged for a human to look at, and every flag reaches the operations board with its signature, counterparty and amount.++## Discovery as a plain document++three.ws publishes everything it sells as one public JSON document at three.ws/.well-known/x402.json, following the open discovery schema. It is cacheable, diffable and readable by anything that can make a GET request, so finding a service is as simple and dependable as reading a file.++Read live on 2026-10-08, it lists 4,522 entries covering 4,499 distinct resource URLs, the difference being priced MCP tools that each get their own row. 4,521 entries carry a Solana mainnet USDC accept, listed first; the remaining entry is an EVM-only demonstration route. Every entry ships a complete input schema, so an agent can call a service from the catalog alone.++The catalog follows one simple rule: it advertises exactly the rails the live 402 serves. A buyer that trusts the catalog gets the same options it will see at the moment of payment. A verification script in the repo checks the live challenges against the discovery document to keep the two in parity. The same catalog is browsable by people at three.ws/x402.++## Offers and receipts: proof that lasts++An entitlement answers whether a caller may do something. A receipt answers whether an exchange happened, and lets a third party check. Between agents and strangers, receipts are what make commerce accountable.++three.ws implements the x402 Offer and Receipt extension. Offers are signed per accepted option with a 60-second validity, so the price an agent was shown is attributable to the seller. After settlement a signed receipt rides in the payment response. The receipt signing key is always separate from every receiving wallet, a rule the issuer checks, so payment keys and commitment keys each do one job.++Receipts are stored and can be fetched long after the response header is gone. A buyer calls /api/x402/my-receipts with a wallet signature, ed25519 for Solana, timestamped and valid for five minutes. The transaction hash is kept out of the receipt payload for privacy and returned only to the wallet that paid. Receipt signing runs alongside settlement and never stands between a buyer and a completed payment. At the 2026-08-25 audit the vault held 58,907 signed Offer and Receipt artifacts.++## Free tools for developers++Anyone building an x402 integration can test against three.ws for free, with no key, at 30 requests a minute per IP.++The echo tool, POST /api/x402/echo, shows exactly what a request looks like from the server's side. If a payment header is present, it is decoded and returned with every signature redacted to a short prefix, along with the same local verification verdict a real paid endpoint runs, without settling or charging anything. That makes it safe to paste into a support thread.++The debug tool, POST /api/x402/debug, takes any part of an exchange (the challenge, the payment, the response) and returns structured findings, each with a severity, the field, the problem and the fix. It catches common slips such as an old protocol version, a shorthand network name instead of the standard identifier, signing for a network the challenge did not offer, decimal amounts where integer atomics are required, and underpayment.++The verify-receipt tool, POST /api/x402/verify-receipt, recomputes an attestation digest to confirm a paid result was not altered, and confirms a settlement transaction on chain. The settlement check also works over a plain GET, so it fits in a browser address bar or an uptime probe. An unreachable RPC is reported as rpc_unavailable, never as a guessed confirmation.++## Where the money goes++Many three.ws endpoints name the real earner as payTo, so the buyer's USDC settles directly into that wallet. A paid skill call pays the skill's author. A 3D asset or animation download pays its creator. A paid service pays its provider. A hired agent is paid in its own payout wallet.++Any public agent with a brain and a Solana payout address can be sold as an API from the Earn tab of its wallet page at three.ws/agent-wallet. The owner sets a price per call in USD, with a floor of $0.001, and a one-line description. The agent gets a stable endpoint on the standard x402 v2 stack, appears in a free public list and in the discovery catalog, and answers before the payment settles, so a buyer is only charged for a reply it received. Requests can carry a message of up to 4,000 characters and up to 20 turns of history, within 32 KB. Every settled call is recorded net of the platform fee, 2.5% by default, and the Earn tab shows calls, all-time and seven-day earnings, and recent payers.++## Honest numbers by construction++three.ws runs a closed-loop payment ring: platform wallets pay the platform's own endpoints in real USDC, settled by the platform's facilitator, to prove continuously that every endpoint settles. It costs only network fees, because the principal recirculates, and it keeps every rail exercised around the clock.++To keep reporting accurate, every settled payment is classified mechanically by payer: internal (a wallet the platform controls), synthetic (not a plausible address at all, such as a test placeholder) or external (a real address the platform does not control). Only external payments count as revenue, and the ring's own settlement endpoint is never listed in the catalog. If the registry of controlled wallets is ever unavailable, the split reports itself as not confident, the readout script exits with an error, and an unavailable figure is shown as null rather than as a number.++The same care protects customers. Platform fee wallets have a daily fee budget that paces internal traffic, and an outside buyer is always admitted ahead of that pacing. Their fee is still recorded against the day, so internal traffic yields to customers.++## Running the rail calmly++A few operating tools keep the rail smooth and easy to read.++Intraday pacing releases each fee wallet's daily budget gradually across the UTC day, so the rail has steady capacity from morning to night. It grants no extra spend; it spreads the same total evenly.++A governed throttle is answered with a retryable 503, so buyers and monitors read it as the platform pacing itself on purpose.++Callers check admission before they pay, using the same math as the settle path, so a paced moment costs a skipped call instead of a full handshake.++The Runway Lab at three.ws/economy-lab runs the production admission-control code against live balances, so an operator can see at a glance whether a wallet needs SOL or is simply being paced.++An audit script reconciles agent wallets against the funding ledger, so capital held across many per-agent wallets is always accounted for and correctly described.++RPC lanes are health-checked with a metered call, so the checks reflect real capacity.++The ring's treasury routes a share of each sweep to the wallet that funds the wider economy, and that share is paid only from genuine surplus, so working capital stays in circulation.++## Our partners++three.ws is proud to take part in eight programmes with some of the most respected names in cloud, AI, hardware, infrastructure and media. Each is listed here exactly as our partners page describes it, and three.ws remains an independent company throughout. Several connect directly to the payment rail in this article.++Google Cloud. three.ws is a member of Google Cloud for Web3 Startups, and production runs on Google Cloud. One Cloud Run service serves the frontend, the route table and every API handler, including the paid endpoints, the facilitator, the preflight attestation and the receipts endpoint, while the scheduled jobs, such as the two-minute settlement reconciliation, run on Cloud Scheduler. Vertex AI provides the Gemini and image lanes.++Quicknode. three.ws is accepted into the Quicknode Startup Program with approved free infrastructure credits. Quicknode's globally distributed RPC endpoints add capacity and redundancy to the chain access behind agent wallets, x402 settlement verification and live Solana market data. Server-side Solana calls run through a failover chain of providers, and Quicknode is a rung in that chain.++Amazon Web Services. three.ws is an AWS Partner. The AWS Marketplace SaaS integration is built and deployed: fulfillment, a signature-verified lifecycle webhook, account linking, and daily metering and entitlement checks. Subscribing links an AWS account to a three.ws account and issues an x402 access key, with usage paid per call over x402. The Marketplace listing is coming, and x402 works directly in the meantime with no AWS account needed.++IBM. three.ws is an IBM Business Partner. Separately, the platform publishes an independent developer tool, the IBM Granite x402 MCP server (@three-ws/ibm-x402-mcp), built on IBM's publicly available Granite models: an MCP client reaches Granite inference and settles per call in stablecoin from a wallet it already controls, with no IBM Cloud account of its own. It is a three.ws tool, separate from the formal partnership work, which is being built on the IBM platform.++OpenAI. three.ws is an OpenAI Select Partner in the OpenAI Partner Network. The free three.ws 3D Studio connector gives ChatGPT keyless 3D tools with no account, payment or key. Its paid sibling, the 3D Studio MCP server, adds rigging, animation, retexturing and analysis, and can be paid per call over x402 or used with OAuth.++NVIDIA. three.ws is a member of NVIDIA Inception, NVIDIA's programme for startups building on accelerated computing. Every 3D generation lane runs on NVIDIA silicon, including text to 3D, photo to avatar, auto-rigging and motion capture, and many of those generations are sold as paid endpoints on this rail.++Alibaba Cloud. three.ws is live on the Alibaba Cloud International Marketplace, with a product listing, a storefront and an editorial feature on the Alibaba Cloud Marketplace blog. Qwen models are first-class lanes in the platform's multi-model brain router.++HackerNoon. three.ws has a builder-focused publishing partnership with HackerNoon. Every three.ws announcement flows automatically from the platform's RSS feed into HackerNoon's drafts queue and, after editorial review, publishes with a canonical link back to three.ws.++You can see all eight on three.ws/partners, and partnership enquiries go to [email protected].++## Why this is the part worth building++The x402 handshake is elegant, and it is only the beginning. What turns machine payments into dependable infrastructure is everything around it: a signed preflight so buyers know before they pay, a single bounded and re-checked retry, a verify that simulates before anyone is charged, delivery before collection, a clear pending state that always tells the truth, one credit per signature, receipts a stranger can check, and books that count real demand precisely. Each of those is a promise kept in open code.++Everything described here is open source at github.com/nirholas/three.ws. To check whether a seller is ready before you sign, use three.ws/preflight. To browse what agents can buy, open three.ws/x402. To watch the rail's admission control against live balances, open three.ws/economy-lab. To sell your own agent's skills, start from the Earn tab at three.ws/agent-wallet. To meet the companies we work with, visit three.ws/partners.++A note on other chains: the same endpoints also accept USDC on Base wherever a facilitator can settle it, always listed after Solana. Solana is the home rail and the one described here.++Nothing here is financial advice.diff --git a/docs/coinmarketcap-article-play.md b/docs/coinmarketcap-article-play.mdindex 58e117ba6..4555d7b41 100644--- a/docs/coinmarketcap-article-play.md+++ b/docs/coinmarketcap-article-play.md@@ -1,139 +1,390 @@----title: "Every Memecoin Is Now a 3D World You Can Walk Into"+title: "Every pump.fun Coin Is Now a Living 3D World You Can Walk Into, Talk In, and Build Together"target: CoinMarketCap Community / Editorial----# Every Memecoin Is Now a 3D World You Can Walk Into+# Every pump.fun Coin Is Now a Living 3D World You Can Walk Into, Talk In, and Build Together-## The community is the asset, so why does it live in a chat box?+## A coin is a crowd, and now the crowd has a place to meet-Strip a memecoin down to what actually moves it and you don't find a product. You find a crowd. The chart is downstream of the community: the holders, the believers, the people refreshing the chart at 3am, the ones aping the next candle and the ones diamond-handing through the dip. On a memecoin, the community *is* the asset.+Ask anyone who loves a memecoin what makes it special and they will rarely start with the chart. They talk about the people. The holders who found it early, the friends who joined later, the jokes, the late nights watching the candles, the shared feeling of being in on something together. On a memecoin, the community is the heart of the whole thing.-And yet that crowd lives in the two loneliest tabs on the internet: a Telegram group on one side, a price chart on the other. The whole point of the thing, the people, has nowhere to actually be. You can't walk into a coin. You can't see who else showed up. You can't feel the market move through a room.+[three.ws](https://three.ws) **/play** gives that community a home you can actually walk into. It turns every [pump.fun](https://pump.fun) coin into a live, shared 3D world. You arrive as an avatar, you see everyone else who showed up, you can talk to them out loud, and the coin's real trading activity plays out around you in the ground, the sky, and the light. When people buy, green waves roll across the plaza. When a big buyer arrives, a column of light shoots into the sky and golden coins rain down. The chart becomes the weather of the place you are standing in.-[three.ws](https://three.ws) **/play** gives the crowd a body. It turns every [pump.fun](https://pump.fun) coin into a live 3D world you can walk into: a shared space where holders show up as real avatars, talk by voice, and watch the coin's on-chain activity ripple through the ground, the sky, and the light around them as it happens. The chart isn't on a screen across the room. The chart *is* the room. Buys roll green across the plaza, a whale lands like a thunderclap, and a coin getting aped looks like a storm of falling gold.+It runs in the browser at **[three.ws/play](https://three.ws/play)**, with nothing to install. Pick a coin and you are standing inside it, next to everyone else who picked it too.-It's live now at **[three.ws/play](https://three.ws/play)**, in the browser, no install, no extension. Pick a coin and you're standing in it, next to everyone else who did.+Since it opened at the end of May 2026, /play has grown from a plaza with a spinning coin into a full open world: a town with streets and storefronts, shops and a bank, jobs to take and cars to drive, fishing ponds and cooking fires, games to play together, builds that last, battles between communities, live events with fireworks, and a free keepsake for everyone who was there. In August, a community meetup hosted with IBM Community's three.ws User Group drew **3,145 avatars into the world at the same time**.++This article is a full tour: what you see when you arrive, what you can do, how a project brings its holders together there, the partners whose technology it runs on, and, for the technically curious, exactly how it works under the hood.++## What you see when you walk in++Open the /play lobby and you see the coin worlds that are trending on pump.fun right now, with a search bar that reaches any pump.fun coin by name or ticker. The lobby opens with three live numbers: how many communities are listed, how many people are standing inside a world at this moment, and what those communities are worth together. Each card shows its own live headcount, so you can see at a glance which worlds are busy. You can sort by what is trending, by most people inside, by biggest market cap, or by newest launch. Cards show how old a coin is, whether it launched in the last day, and whether it is still on its bonding curve. Press the slash key and the search bar is ready for you.++Pick a coin and you drop into its world as a 3D avatar. In the middle of the plaza stands a giant, slowly turning gold coin stamped with that token's art. A stadium-sized screen towers over the square, showing the coin's name, its live market cap, and how many people are in the community right now. Beyond the plaza, a whole district unfolds: avenues, sidewalks, lit buildings and streetlights, ringed by a landscape that belongs to this coin alone.++Other people are there with you: real avatars, moving and waving, with names floating above their heads and chat bubbles when they speak. On a computer you move with WASD and the mouse. On a phone you get a touch joystick. You can sprint, jump, and switch between four camera styles (follow, cinematic, first person, and top down) with the C key. Hold Q and a full emote wheel opens with around seventy animations in five families: social moves, dances, flips, combat moves, and poses. Tap one of six reaction buttons and a floating emoji rises over your head for everyone to see.++The sun moves too. Every world shares one clock, so day turns to dusk and dusk turns to night for everyone at the same moment, and the district's windows and streetlamps glow on as the sky darkens.## One coin, one world-The mental model is simple: **every coin is a room, keyed to its mint address.**+The idea at the center of /play is simple: **every coin is its own world, keyed to its mint address.**++When you enter a coin's world, you are matched only with other people who entered the same coin. Each community gets a space of its own, and the people you meet there are the people who chose that coin. Walk into a different coin and you are among a different crowd, in a different place.++That makes a community shareable as a single link: `three.ws/play?coin=<mint>`. Send it to someone and they land directly in your coin's world. Post it in a chat, a blog, or a forum that supports rich previews and it unfolds as a preview of the live world itself.-You open the /play lobby and see the trending pump.fun coins, plus a search box that reaches every coin on pump.fun, not just what's hot, *any* token. Pick one. You drop in as a 3D avatar standing on a plaza, under a sky, with a giant slowly-turning gold coin in the middle stamped with that token's art. A stadium jumbotron towers over the plaza showing the coin's name, its live market cap, and a count of how many people are in this community *right now*.+## Two doors: the open world and the holders' world-Other people are there too: real avatars, moving, with names floating over their heads and chat bubbles when they talk. You move with WASD and the mouse on desktop, or a touch joystick on mobile; sprint, jump, orbit the camera, wave an emote. Everyone in that space entered the same coin. Walk into a different coin and you're with a different crowd, in a different world.+A coin's world has two connected spaces, each with its own purpose.-Under the hood this is enforced by the multiplayer server: players are matched into the same room instance **only when their coin matches**. Each token is an isolated world. There's no bleed between communities: the people in $DOGE's world and the people in some fresh launch's world never see each other, because they're literally in different rooms anchored to different mints. A community becomes a shareable URL (`three.ws/play?coin=<mint>`); send it and someone lands directly in your coin's world.+The **open world** is the front door, and it welcomes everyone. Anyone can drop into any coin with no wallet at all: walk the plaza, watch the market move the sky, read the live trading screen, talk to the people nearby, play the games, and buy the coin if the place wins them over. It is where curious visitors become community members.-## Anyone can walk in. Holders get a room of their own.+The **holders' world** is the members' space. To step inside, you show that you hold the coin. By default the bar is **at least $8 worth of the coin**, and a coin's creator can choose their own requirement instead, set as a number of tokens. Everyone you meet in the holders' world has passed that same check, so every conversation there is among people who share a stake in the same coin.-Not every crowd is the same crowd. There's the passer-by who clicked a link to see what a coin's world even looks like, and there's the holder with real skin in the game. /play gives a coin both, as two connected worlds.+Checking your holding takes a few taps. You sign in through [Coin Communities](https://coin-communities.xyz), the social layer each coin's community runs on, using your X account and a linked Solana wallet. The three.ws server then reads your linked wallets (up to five, added together, so a holder who keeps the coin in a second wallet is recognized), prices your holding of that exact coin on-chain, and, once you clear the bar, issues a signed holder pass that the world server checks before it lets you in. The wallet always comes from your signed-in account, so the pass reflects the wallet you actually linked. If you are a little short, the gate shows you exactly how much you hold and offers a one-tap way to buy the rest, or to step into the open world straight away instead.-The **open world** is the front door. Anyone can drop into any coin, no wallet required: walk the plaza, watch the market move the sky, read the live terminal, and ape in if the world wins you over. Think of it as the trailer for the community.+Holders get some extra room to create, too. In the holders' world the build tool's clearing reach is twice as wide as in the open world (36 meters instead of 18), so holders can shape a real place together.-The **holders' world** is the community itself, and it's gated. To step through and actually take part, to talk, to build, to post into the coin's living feed, you have to hold at least **$8 worth of the coin**. That bar isn't a velvet rope three.ws invented. It's enforced through [Coin Communities](https://coin-communities.xyz), the protocol that powers each coin's social layer, which only lets verified holders participate in a token's community. Being in the room is itself proof that everyone around you has a stake in the same coin you do.+### How a project brings its holders in-It's the oldest idea in crypto finally given a place: holders together, in a space only holders can enter. The market the world reacts to is the market everyone in that room is exposed to. When the totem spins and golden coins rain down, nobody in the holders' world is a tourist; the green ripping across the plaza is *their* green.+For a coin's creator or community team, /play is a ready-made home to send people to.-Send someone the open world and they can look around. Send them the holders' world and, if they're holding, they're home.+- **One link for the whole community.** Share `three.ws/play?coin=<your mint>` for the open world, or add `&tier=holders` for the holders' world. The holders' link runs the gate every time it is opened, so it works as a standing invitation for anyone who holds.+- **Your own entry requirement.** The verified creator of a coin sees a button in the world to set or change the token amount the holders' world requires. The server confirms the creator's wallet against the coin's on-chain creator before saving it.+- **Creator moderation.** The creator can remove any piece built in their world, and can clear an area or the whole world in one action, with the widest clearing reach of anyone.+- **Revenue from style.** When a player buys a premium cosmetic from the tailor's shop inside your coin's world, a share of the settled USDC is paid to the coin's creator wallet on Solana. The default share is 50 percent, and a creator can sign a message to set it as high as 90 percent. Earnings show up in the creator's Monetize dashboard.+- **A community feed.** Each coin's Town chat is powered by Coin Communities, so the conversation that happens in the world lives alongside the coin's wider social feed.-## The world reacts to the chain+## The world moves with the market-This is the part that makes people stop and stare.+This is the moment most people remember from their first visit.-Every /play world is streaming that coin's **real on-chain trades** (the actual pump.fun swap tape) and piping them straight into the environment. The market doesn't sit politely on a panel. It physically moves the world around you:+Every /play world streams its coin's **real on-chain trades** from pump.fun and turns them into the environment around you:-- **Every buy ripples green** across the plaza and kicks the glowing boundary ring.-- **Every sell ripples red.**-- **Sustained volume spins the coin totem faster:** the room visibly speeds up when the tape heats up.-- **The rolling percentage change becomes the weather.** Green and the fog opens out, the sun flares: euphoria. Red and the fog closes in and the light dims: a storm rolls over the world. The mood drifts like a tide, not a strobe, so it reads as atmosphere rather than noise.-- **A whale trade detonates.** When a single trade crosses the whale threshold, a column of light fires up over the totem, a shockwave rolls out across the plaza, and on a big buy a fountain of golden coins rains off the top, with a toast naming what just happened ("🐋 Whale bought $X of $TICKER").+- **Every buy sends a green ripple** across the plaza and makes the glowing boundary ring flash.+- **Every sell sends a red ripple.** Bigger trades hit harder, with a brighter flash.+- **Busy trading spins the giant coin faster.** When the tape heats up, the whole plaza visibly picks up speed.+- **The recent percentage change becomes the weather.** When the coin is climbing, the fog opens out and the sun shines bright. When it dips, the fog rolls in and the light softens into a storm. The mood drifts gently like a tide, so it reads as atmosphere.+- **A big trade becomes a celebration.** Any single trade of $750 or more earns the full spectacle: a tall column of light fires up over the coin, a shockwave rolls across the plaza, and when it is a buy, the column glows gold and a fountain of golden coins sprays off the top. A notice appears on screen naming what happened, along the lines of "Whale bought $X of $TICKER".-The coin's price becomes the room's pulse. You don't read the market; you stand inside it and feel it flinch. A quiet coin is a calm, still world. A coin getting aped into orbit is a thunderstorm of green light and falling coins. Nobody has to narrate the action in chat; the world *is* the action.+The coin's price becomes the room's pulse. A quiet coin is a calm, still world. A coin having a big day becomes a thunderstorm of green light and falling gold. Everyone standing in the plaza feels the same moment at the same time, which makes the market something a community experiences together.## A trading terminal you can walk up to-Atmosphere is one half. The other half is a real, legible terminal, because people in a coin's world want the numbers, not just the vibe.+Next to the coin stands a second giant screen: a live **trading terminal** for the coin, built right into the world. It checks the coin's on-chain trade feed every five seconds and paints, as the trades land:-Past the totem stands a second giant screen: a live in-world **trading terminal** for the coin. It's not a decoration and it's not a screenshot. It polls the same on-chain swap feed the rest of the platform uses and paints, in real time:+- the **price**, written in the compact sub-decimal notation small-cap coins need (for example $0.0₇123),+- a **price chart** for your session with a live, glowing line,+- the **market cap**, the **trading volume**, and a **buy and sell pressure** bar showing which side is leading,+- and a **scrolling ticker of the latest real trades**: whether it was a buy or a sell, its size in SOL and in dollars, the trader's short address, and how long ago it happened.-- the **price** (with the leading-zero sub-decimal notation memecoins need: $0.0₇123 and the like),-- the session **price chart** with a live, glowing line,-- **market cap**, **live volume**, **trade count**, and **buy/sell flow** as a pressure bar,-- and a **scrolling ticker of the latest real trades**: side, size in SOL and USD, the trader's short address, and how long ago.+Tap the screen and it opens the coin on pump.fun.-Tap the terminal and it opens the coin straight on pump.fun. And you don't even have to leave: /play ships a native in-world **buy flow**. Click Buy and the three.ws server builds the unsigned pump.fun transaction (handling both the bonding curve and the post-graduation AMM), your Solana wallet signs it, and it broadcasts. You can ape the coin while standing inside its world, surrounded by the people who already did.+### Buying from inside the world-That's the loop a memecoin has never had in one place: *see the crowd → feel the market → read the tape → buy the coin*, without ever switching tabs.+You can also trade the coin right where you stand. Click Buy and a trade panel opens inside the world. The three.ws server prepares the pump.fun transaction for you, whether the coin is still on its bonding curve or has graduated to its trading pool, and whether it is paired with SOL or with USDC. Your own Solana wallet signs it, and the transaction is sent through the platform's own Solana connection.-## Walk up to someone and talk+The panel is designed to help you trade with confidence. It shows a live quote, slippage presets of 1, 3 and 5 percent, your balance, and any platform fee up front. Before the Buy button, a safety panel shows a score from the platform's pre-trade checks, with a plain-language note for each on-chain check it ran. Selling works the same way, with quick buttons for a quarter, half, or all of your holding.-A crowd you can't talk to is just wallpaper. Inside the holders' world, /play has **spatial voice chat**, and it's the thing that makes a coin's community feel like a real gathering instead of a chat box with 3D models.+If you have built an AI agent on three.ws and it holds SOL in its own wallet, you can pick that agent as the payer. The agent places the trade from its wallet, under the same spending guardrails it uses everywhere else on the platform, and no browser wallet extension is needed.-It works the way your ears do. Walk up to someone and you hear them. Drift away and they fade out. Their voice comes from *their direction*: someone on your left sounds like they're on your left. Get far enough and they're gone. The audio is genuine peer-to-peer WebRTC with HRTF spatial panning and distance falloff; the server only passes the connection handshake between two people and never touches the audio itself. Connections open only to the people near enough to hear, so the voice layer stays light no matter how busy the plaza gets, which is also exactly what spatial audio *should* do.+That completes a loop every coin community enjoys: see the crowd, feel the market, read the tape, and buy the coin, all in one place.-Voice is opt-in (the mic stays off until you tap it), and when someone's talking, their nameplate pulses so you can pick the speaker out of a crowd. Alongside it there's text chat with floating bubbles and a set of emotes. The result is that a coin's world feels less like a Discord and more like actually being *somewhere* with other holders: clusters of people talking near the totem, someone shouting across the plaza when a whale lands.+## Talk to the people next to you-## A thousand coins, a thousand worlds+Every coin world has **spatial voice chat**, and it is what makes a coin's world feel like a real gathering.++It works the way your ears do. Walk up to someone and you hear them clearly. Wander away and their voice fades. Their voice comes from where they are standing, so someone on your left sounds like they are on your left. Clusters form naturally: a few people chatting by the coin, a group laughing near the dance floor, someone calling out across the plaza when a big buy lands.++Voice is your choice. Your microphone stays off until you tap the Voice button, and tapping again mutes you. When someone is speaking, their nameplate pulses so you can pick them out of a crowd.++Alongside voice there is text chat with floating speech bubbles, the emote wheel, and the reaction buttons. Names and chat are filtered for hate speech, and the online counter in the corner counts real people only, so the number you see is the number of people who are really there.++## Meet the town++A coin's world is lively even before your friends arrive.++**The walkers in the crowd are real.** The people strolling the plaza wear real community avatars from the three.ws public gallery, and many of those avatars belong to registered three.ws AI agents, each with its own wallet and earned reputation. Click a walker's nameplate or tap their body and their profile opens: the live agent behind them, their trust score, wallet and holdings. Press "Talk 1-on-1" and you start a real, streamed conversation in which they answer in character as themselves. While you talk, they stop, turn to face you, and catch back up with the crowd when you say goodbye.++**The townsfolk run real businesses.** A cast of characters stands at counters around the plaza, offering real paid services such as market reads, fact checks, security scans, vanity addresses, 3D model forging, and coin launches, each settled on-chain in USDC over x402, the open pay-per-call standard. Walk up, press E, and talk to them first: their conversation streams live from the three.ws brain router, and you can switch the AI model mid-conversation from a picker. They know which coin's plaza they are standing in.++**The Intel Kiosk sells live market data.** Walk up, press E, and buy a live market reading (price, 24-hour change, market cap, and an overall signal) for one cent of USDC, paid from your own wallet and settled on Solana.++**Your friends come with you.** Press J to open the friends drawer: your three.ws friends list, who is online and which coin world they are in, friend requests, and private message threads, all without leaving the world. Signed-in players carry a verified @handle on their nameplate, confirmed by the server. Click anyone, or press I, to open their three.ws profile card: their bio, followers, latest 3D creations, a follow button, and a one-tap way to message them.++## A world with a life of its own++In July 2026 the plaza grew into a full open world with a real economy, and it is one of the most enjoyable parts of /play.++### Gather, cook, and sell++Around the district you will find a grove of trees, a quarry of rocks, two fishing ponds with animated water, and roast pits. Pick up an axe and chop wood. Grab a pickaxe and mine stone, with a chance of coal. Cast a line at the ponds and reel in fish, then cook your catch over a roast pit. Spare fishing rods lean on posts around the map, ready for anyone who wants one.++Everything you gather can be sold for cash at the General Store. Cooking adds real value: a cooked fish sells for three times the price of a raw one. Five skills grow as you play (combat, woodcutting, mining, fishing, and cooking), each reaching level 99. You carry a 24-slot pack and a 6-slot hotbar, and stackable items go up to 999 per stack.++### The store and the bank++Walk up to the General Store clerk and press E to buy tools (a rod, an axe, a pickaxe, a hammer), a melee weapon, health potions, an armor vest, and ammo, or to sell what you have gathered. The server prices every trade from one price table, the same table the store screen is drawn from, so the price you see is always the price you pay.++Walk up to the Bank Teller to deposit your cash into a protected balance. Banked cash is always safe, so a trip to the bank before heading out on an adventure is part of the rhythm of the game.++The whole economy is published. **[three.ws/play/economy](https://three.ws/play/economy)** shows every price, every catalog, and the odds of every prize, read live from the same modules the game server uses, and the same data is free to read as JSON at `/api/play/economy`.++### Two currencies, each with its own job++The economy runs on two currencies with clearly separate roles. **Cash** is the game's own currency: you earn it by playing, spend it on tools and supplies, and it lives in your character's profile. **$THREE**, the platform's coin, is used for premium style. That clean split keeps play rewarding for its own sake and keeps style a matter of choice.++### The $THREE boutique, the tailor, and your wardrobe++Premium items in your wardrobe show their $THREE price and unlock with a real on-chain $THREE payment from your connected Solana wallet. The server quotes the price from its own catalog, you sign one transaction, and the server confirms that transaction on Solana before the item is yours. Each payment grants exactly one item, tracked in a shared ledger across every world and server. Every boutique sale splits 50 percent to the holder-rewards pool and 50 percent to the treasury.-If every coin shared one generic world, the whole thing would feel like a template. It doesn't.+Fashion has a physical home in the world, too. Roux the Tailor runs a cosmetics shop where you can filter by rarity, preview any item live on your own avatar, and buy premium pieces with USDC over x402, with value quoted in $THREE. Nell's Fitting Room lets you equip anything you own. Avatars can wear hats, glasses, and earrings, and everything you own follows you into every coin world.-Each coin's world is generated **deterministically from its mint address**. The mint is hashed into a seed, the seed picks one of several biome archetypes (Verdant Meadow, Dune Sea, Frostfields, Ashen Caldera, Neon Expanse, Lagoon Shore) and then nudges that biome's palette and scatters its flora from the same seed. So a given coin **always** renders the same world (your coin's place is *its* place, every time you return), and a thousand different coins render a thousand recognizably different ones. Two tokens that happen to land in the same biome still get their own color and layout.+### Fortune's Folly-Walking into a new coin and seeing what world it "is" becomes its own small ritual: a frozen tundra, a neon alien expanse, an ashen volcanic caldera. The world is a fingerprint of the mint.+In the plaza stands Fortune's Folly, a twenty-wedge wheel. Everyone gets a free spin every twelve hours, and you can pay $3 worth of $THREE for another spin, split the same 50 and 50 way and confirmed on-chain before any prize is awarded. Prizes are wood, stone, coal, or cash, and every wedge has equal odds, exactly as the wheel shows. The wheel opens once your average skill level reaches 3, so it rewards players who have spent a little time in the world, and the server makes sure your pack has room for any prize before you spin.++## Jobs, cars, and the open road++**The Jobs Board.** Five quest-givers stand around town: Dockmaster Reyes, Warden Okoro, Cook Mara, Foreman Dell, and The Fixer. Walk up and press E to open the Jobs Board, accept a job, and a waypoint appears at your goal. Some jobs ask you to reach a place, others to interact with something when you get there, and finishing pays real cash, recorded by the server.++**Driving jobs.** Two of the jobs are real driving missions: Cross-Town Delivery runs north to south, and East-West Express runs east to west. Grab a car at one of the avenue depots and drive the rush order to the depot on the other side of town. Each leg counts when you complete it at the wheel, so it is a true delivery run.++**The Trench Car.** The car in /play is the Trench Car, a community model from the three.ws avatar gallery. You see it everywhere: ambient traffic drives it around every town, and one waits in every vehicle bay, so the car you watch drive past is a car you can climb into. Walk up and take the wheel, then drive with WASD, or with on-screen pedals and a steering wheel on a phone. It runs on real physics, so it rolls over the same streets and bumps into the same buildings your avatar walks among. Other players see you behind the wheel in a seated pose, and each car seats one driver at a time.++## Adventure beyond the town++The town itself is a peaceful place. Out past its edges lie three named wild areas, the Southern Wilds, the Northern Wilds, and the Eastern Marches, where adventure lives.++Equip a sword, a bat, a pistol, or a bow from your hotbar and head out. Creatures roam the wilds and give chase. Defeat one and it leaves behind a marker you can loot for cash and items. A heads-up display in the style of classic open-world games shows your health, armor, and wanted level. If you take a fall, you respawn back in town at full health a moment later, and your banked cash is always waiting for you. Every hit, every loot, and every respawn is decided by the server.++## Play together++Some of the best moments in /play are simple games with the people around you.++- **King of the Totem.** A glowing gold ring sits at the base of the coin. Stand inside it alone and you earn points every second, with a crown floating above your head. When a second player steps in, the zone is contested and the race is on. Rounds last 90 seconds, with a live countdown, a scoreboard that highlights your own row, and a winner banner with a burst of confetti. The server decides every point from real positions.+- **Tag.** A game of tag for two or more players, refereed by the server from real positions.+- **The dance floor.** A disco floor in every world, perfect for a group dance.+- **The beach ball.** A kickable ball in every world, with server physics so everyone sees it fly the same way.## Build it together, and it stays-A community's world isn't read-only. /play includes **collaborative voxel building**: a block palette and a build mode where anyone in the holders' world can place and break blocks together, in real time, on a shared grid in the middle of the plaza.+A coin's world is a canvas its community shapes together.++**Blocks and structures.** Turn on build mode and a block palette appears. Blocks snap to a 1.5 meter grid and rotate in quarter turns, so everything lines up neatly. A structures toolbar stamps whole shapes at once: a wall, a floor, a staircase, or a doorway, with a live preview you can rotate before you place it. Every block type is drawn efficiently, so even large builds stay smooth.++**Props.** A props palette offers hand-built pieces (crates, barrels, planters, lamps, benches, pillars, arches, ramps, signs, crystals, a stage) plus the whole library of public community models, which you can search and stream in. A translucent preview follows your aim and glows green where your piece will land.++**Forge an item straight into the world.** Describe something in the Forge form, or just type `/forge a mossy stone lantern with a copper roof` in chat, or attach a reference photo. About half a minute later a real textured 3D model is added to your props, ready to place. It is free, needs no account or wallet, and the finished piece appears for everyone in the world.++**Everything persists.** What a community builds stays. Blocks and placed objects are saved on the server and restored the moment the first person returns, so the monument your community raised is still standing tomorrow. Each world can hold 200 placed objects, each player can have 30 at once, and each builder has a personal budget of 1,200 blocks, so there is always room for everyone to contribute. The areas around the spawn point and the coin are kept clear, so the heart of the plaza always stays open.++**Share your creation.** The share button takes a clean screenshot of your build, lets you name it, copy a link, download the image, or publish it to the coin's featured builds, a gallery for each world that links every creation back into the world so others can drop straight in and see it.++## Coin Wars: communities meet in the arena++Every coin world's plaza has a **war portal**. Walk up and its board lights up with your community's standing in the Coin Wars league: its Elo rating, rank, record, kill and death ratio, and recent battles.++Press E and the portal checks that you hold the coin (the same check the holders' world uses), then puts your community in line. When another community queues, both sides are sent into the same arena at `/play/war` to battle. The first side to reach the kill cap wins, the result is written to a battle ledger, and the league standings update from it.++While a war involving your coin is running, the portal board becomes a live scoreboard, with the score, the round clock, and a kill feed, so everyone back in the plaza can cheer along. When the battle ends, "Back to the world" returns you to the exact world you left, with the result already shining on the board.++## Live events, fireworks, and souvenirs++/play has a full live-events system, built for the $THREE town, and it is how the community gathers for big moments.++When an event is scheduled, a countdown chip appears at the top of the screen from a day out and turns into a LIVE marker when the event begins. Tap it to open the full running order: what just finished, what is on now, and when each remaining segment starts, in your own time zone. The same drawer shows a live $THREE price row, a one-tap buy button, and a button to take a commemorative photo. Each time the schedule moves on, a banner announces it across the plaza.++When the event goes live, **fireworks fill the sky** over the town. Every player sees the same shells in the same places at the same moment, and the show builds to a grand finale.++A public landing page at **[three.ws/event](https://three.ws/event)** is the one link to share. It shows the countdown, a single button into the event world, a plain-language guide to what to expect, the schedule in the visitor's own time zone with an Add to Calendar button, and, while the event is live, the real number of people standing in the world.++### A keepsake for being there++Everyone who walks into the event world while an event is live receives a **free commemorative wearable**, once, to keep forever, and it can be worn in every coin world. For the first meetup it was the Meetup Laurel, a gold laurel circlet with three pearl berries at the front. A card slides in at the corner of the screen to tell you what you received, with a button to put it on right away. Souvenirs are granted by the server and kept off the shop shelves for good, so wearing one means you were there.++### The day 3,145 avatars came to the $THREE town++On August 7, 2026, the **three.ws User Group on IBM Community** held its first meetup entirely inside /play. It ran for nine hours, from 8 AM to 5 PM Pacific time, and the world was open to anyone with the link. Concurrency climbed past a thousand early in the day and peaked at **3,145 avatars in the world at the same time**.++The program ran as planned: a live tour of the platform from inside the world, community demos, and open questions and answers, including the two open-source connectors that link three.ws agents to IBM watsonx.ai and Granite models. The conversation wandered happily into everything else people wanted to try: Forge's free text-to-3D, the Avatar Studio's automatic rigging, the shared wardrobe, and the embed that puts a three.ws avatar on any website.++Many of the best moments happened between agenda items. Attendees spent the afternoon fishing together, cooking their catch, and driving cars around the map. The group's organizer on the IBM Community side published her own recap describing exactly that, and the three.ws team's recap lives at [/blog/ibm-user-group-first-in-world-meetup-recap](https://three.ws/blog/ibm-user-group-first-in-world-meetup-recap).-It's server-authoritative: every block is validated and synced through the same room everyone's in, so what you build is what everyone sees. And critically, **builds persist**. The world's creation is saved per coin and rehydrated when the room spins back up, so a community's monument to their token survives even after the last person logs off and the room is torn down. Come back tomorrow and the thing your community built is still standing.+The meetup showed what a coin world can be for a community: a venue where a crowd of thousands can gather, talk, play, and celebrate in one shared place, in the browser.-That's the difference between a chat log and a place. A chat scrolls away. A place accumulates.+## Your avatar, your way++You choose how you look in every world, and there are many ways to do it.++**Before you enter.** The lobby's avatar row lets you design an avatar from scratch or from a selfie, upload your own `.glb` model, or sculpt one in the full Avatar Studio. No sign-in is needed.++**Selfie to avatar.** The three.ws selfie flow turns a photo of your face into a rigged 3D avatar that is ready to walk, wave, and dance.++**Forge and Avatar Studio.** Forge turns a sentence into a textured 3D model, and the Avatar Studio goes a step further by adding a skeleton, so whatever you create can walk and sit like everyone else in the world.++**Bring your three.ws agent.** If you have built an AI agent on three.ws, it can come with you. Your saved three.ws avatars appear right in the picker.++**Change without leaving.** Inside any world, press V or tap the Avatar button to swap your look on the spot: choose from your saved avatars, community quick picks, the full public gallery, a pasted link, an uploaded `.glb` or `.vrm` file, or the avatar creator. Your new look appears on you instantly, and everyone else sees it live.++**Every rig is welcome.** three.ws reads the bone names of whatever avatar you bring (Mixamo, Avaturn, Unreal, VRM and VRoid, VRM 1.0, Daz and Genesis, MakeHuman, Blender's naming style, and more) and maps them onto one shared skeleton, so an avatar made almost anywhere walks, idles, and emotes correctly the moment it loads. Compressed models load smoothly too, including Draco- and meshopt-compressed files.++## Photo mode, zen mode, and sharing++**Photo mode.** Press P, or tap the camera button, and the world lands on a clean share card: your shot, the three.ws mark, the coin's name and symbol, the date, and, during a live event, the event's name. The shot is a fresh render of the scene, so the on-screen controls, chat, and name tags stay out of the frame for a clean picture. Download it or copy it straight to your clipboard while the world keeps running behind the preview.++**Zen mode.** One key hides the whole interface for an uninterrupted view of the world, and a zen-mode link stays a zen-mode link when you share it.++**Links that unfold.** A coin-world link shared in WordPress, Ghost, Discord, dev.to, or Notion unfolds as an interactive preview of the live world, thanks to a built-in oEmbed provider.++**Embeds for partners and projects.** A /play world can be embedded in another site, with settings that help it fit in: `?biome=<id>` pins its look (for example `?biome=noir` for a neutral dark world called Midnight), and `?bg=transparent` lets the world sit directly on the host page. The IBM partnership demo on three.ws uses exactly this to show a live coin world on a dark stage alongside its other 3D demos.++## On your phone and on the Seeker++/play is built to run beautifully on phones. Touch controls cover everything: a joystick for walking, a long press for the emote wheel, pedals and a steering wheel for driving, and tap-to-place for building. Phones download a phone-sized copy of the world's lighting (about 360 KB instead of 1.4 MB) that carries the same light, and coin artwork arrives at the size it is drawn, so worlds load quickly on mobile connections.++A shared frame-rate governor keeps devices cool and batteries happy: 60 frames per second while you are playing, 30 when the window is in the background, and a Power Saver switch for an even lighter, quieter experience that carries across the platform's 3D surfaces.++three.ws is also a **native app on the Solana Seeker**: version 1.0.0 is approved and live on the Solana dApp Store. The app opens three.ws full screen, sign-in is a single tap through the phone's Seed Vault using Mobile Wallet Adapter, and any three.ws link opens inside the app, so a /play invitation lands straight in the world. Google Play and iPhone apps are coming next.++## A thousand coins, a thousand worlds++Every coin's world has its own look, created **deterministically from its mint address**. The mint is turned into a number, and that number chooses one of seven landscapes:++- **Verdant Meadow**, rolling green fields,+- **Dune Sea**, golden desert,+- **Frostfields**, a snowy tundra,+- **Ashen Caldera**, a volcanic basin,+- **Neon Expanse**, a glowing alien plain,+- **Lagoon Shore**, a tropical coast with palms,+- **Dust Gulch**, an old-west frontier town.++The same number then shifts that landscape's colors and scatters its trees and plants, so two coins that share a landscape still get their own palette and layout. A coin always renders the same world every time you return, which makes it feel like a real place, and a thousand coins render a thousand recognizably different ones. Discovering what world a new coin "is" becomes a small ritual of its own.## The flagship: the $THREE town-There's one world that's always pinned to the top of the lobby, badged official, dressed in a fixed signature biome instead of the seeded lottery: the **$THREE town**, three.ws's own coin community. It's the front door (the world a first-time visitor lands in), and its identity (name, art, market cap) refreshes live from pump.fun so the pinned card is never stale. It's also the proof that this isn't a tech demo bolted onto a homepage: the platform runs its own community in its own product.+One world is always pinned to the top of the lobby, badged as official: the **$THREE town**, home of three.ws's own coin community. It is the front door, the world a first-time visitor lands in, and it wears a signature look chosen for it: Dust Gulch, a frontier town with a packed-dirt square ringed by false-front storefronts like a saloon, a bank, and a sheriff's office, a water tower on the skyline, and tumbleweeds drifting across the mesa under a low golden-hour sun. Its name, art, and market cap refresh live from pump.fun, so its card is always current.++The $THREE town hosts the platform's live events, including the August meetup, and the full town experience it pioneered (the townsfolk, the economy, the games) now travels to every coin world on /play.++## Built with partners++/play is a showcase of what three.ws builds with the programmes it belongs to. Each is described here with its exact designation.++### Google Cloud++three.ws is a **member of Google Cloud for Web3 Startups**, and production runs on Google Cloud. The multiplayer server behind every /play world runs as its own Cloud Run service, `three-ws-multiplayer` in us-central1, deployed separately from the main site because a fleet of long-lived WebSocket connections scales in its own way. The site, the APIs, and the GPU workers that generate 3D models and avatars run on Cloud Run too, with scheduled jobs on Cloud Scheduler and Vertex AI providing the Gemini and image lanes.++### NVIDIA++three.ws is a **member of NVIDIA Inception**, NVIDIA's programme for startups building on accelerated computing. Every 3D generation lane on the platform runs on NVIDIA silicon: a self-hosted Cloud Run GPU fleet (L4 GPUs plus an RTX PRO 6000 Blackwell) behind text-to-3D, rigging, and motion, and a free hosted lane behind chat, vision, embeddings, safety, and speech. That is the hardware behind the avatars people walk around in and the props they forge into their worlds.++### IBM++three.ws is an **IBM Business Partner**, and IBM Community hosts a dedicated three.ws User Group, the group that held its first meetup inside the $THREE town and drew 3,145 avatars at its peak. The public `/api/ibm` Granite tools on three.ws are independent developer tools built on IBM's publicly available Granite models.++### Quicknode++three.ws was **accepted into the Quicknode Startup Program** in July 2026 and approved for infrastructure credits. Quicknode is one rung in the platform's Solana RPC failover chain, the set of providers behind live Solana market data, agent wallets, and the on-chain confirmation that settles purchases. In /play, that chain carries the reads and confirmations behind in-world buys and boutique payments.++### Alibaba Cloud++three.ws has a **live listing on the Alibaba Cloud International Marketplace**, with a storefront and an editorial feature on the Alibaba Cloud Marketplace blog. Alibaba Cloud's Qwen models are first-class lanes in the three.ws brain router, the same router the /play townsfolk stream their conversations from, so a player can choose a Qwen model from the picker while chatting with a character in the plaza.++### OpenAI++three.ws is an **OpenAI Select Partner** in the OpenAI Partner Network, as an independent member. The free three.ws 3D Studio connector gives ChatGPT eleven keyless 3D tools, including text to model and rigged avatars, rendered inline in the conversation. A rigged avatar made that way is a 3D model with a link, ready to paste into the /play avatar picker and wear into a coin's world.++### Amazon Web Services++three.ws is an **AWS Partner**. The AWS Marketplace integration is built, and the Marketplace listing is coming next.++### HackerNoon++**HackerNoon** is three.ws's publishing partner. three.ws announcements flow automatically from the platform's announcements feed into HackerNoon for its developer audience.++### Coin Communities++[Coin Communities](https://coin-communities.xyz) is the social layer each coin's community runs on in /play: the X sign-in, the linked wallets the holder check reads, and the Town chat feed for every coin.++## Under the hood++For readers who want the engineering, here is how /play works.++### An authoritative multiplayer server++The worlds run on an authoritative [Colyseus](https://colyseus.io) server, a single Node process that hosts several room types: `walk_world` for /play and /walk, `clash_arena` for Coin Wars, and others for the platform's Living Stages, AR studio, and more. It runs as the `three-ws-multiplayer` Cloud Run service.++Clients send their movement about **15 times per second**. The server validates every update before accepting it: a maximum step per message (1.2 meters, generous headroom over a running stride of about 0.27 meters per update), world bounds that match the rendered 400 meter district, name length, and per-message rate limits for every kind of action. It keeps the authoritative state and broadcasts it at 15 Hz using Colyseus's **binary delta protocol**, which sends only the fields that actually changed to everyone else in the room.++Rooms are matched by coin and access tier (`filterBy(['coin','tier'])`), which is what gives each coin its own world and keeps the open world and the holders' world as separate rooms. Each room instance welcomes up to 100 people, and the matchmaker opens another instance of the same world as one fills, which is how a single event can welcome thousands. Horizontal scaling across server instances is wired behind Redis.++Gameplay is server-authoritative throughout. The client sends an intent (chop this tree, sell these fish, deposit this cash, spin the wheel, swing this sword) and the server checks the tool, the range, the cooldown, the pack space, and the price before it changes anything, then streams the result back. Store, bank, and wheel actions are accepted when the player is standing at the counter or the wheel, and cars report speed and position that the server checks against each vehicle type.++### Persistence++Player progress (cash, inventory, skills, and cooldowns) is saved durably on the server and survives restarts. Each coin's builds are saved through a debounced write-through to Postgres and object storage, which batches rapid edits into a single round trip, and are restored before the first player of the day sees the world. Purchases settle against a shared Redis-backed ledger that records both the quote and the transaction signature, so each payment grants exactly one item across every world, restart, and instance. Sign-in to a coin world lasts 30 days.++### The holder pass++The holders' world is admitted with a signed pass. The API reads the signed-in user's linked Solana wallets from their Coin Communities session, sums their holding of the exact mint, prices it through the platform's balance and price sources (falling back to the pump.fun bonding curve for brand-new coins), compares it to the creator's token threshold or the platform's dollar floor, and seals the result into an HMAC-SHA256 token. The multiplayer server re-derives the signature with a shared secret and checks the mint, the tier, and the expiry in its join handler, so admission needs no RPC call inside the game server at all.++### Shared time without network traffic++Several things everyone sees at once are computed from the clock rather than sent over the network. Day and night come from one deterministic world clock shared with the /walk scene. Event fireworks are planned in four-second buckets hashed with the event's id, so every client draws the identical sky. At most 14 shells are in the air at once, Power Saver halves the density, and a tab that comes back from the background rejoins the show live. Pedestrians and ring-road traffic follow a deterministic navigation graph, so they look the same to every player with zero packets.++### Deterministic worlds++A coin's mint is hashed with FNV-1a into a stable 32-bit seed. The seed selects one of the seven natural landscapes, jitters its palette in hue and lightness, and scatters its vegetation, with no randomness in the layout path, so identical input always yields the identical world. Two curated looks sit outside the seeded set and are reached only by name: Midnight for embeds, and Ticker Row, the dark ticker-tape palette used by the Robinhood Chain memecoin worlds, which run on the same machinery with a trade feed of their own.++### Spatial voice++Voice is a proximity-gated WebRTC mesh. Audio travels peer to peer, and the Colyseus room only relays the connection handshake between two players. A connection opens when another voice user comes within 27 meters and closes past 33 meters, a gap that keeps connections steady when someone paces the edge. Each player holds connections to their 8 nearest voice peers. Every incoming voice runs through a Web Audio panner using **HRTF** spatialization, positioned at the speaker's location, with full volume within 3 meters fading linearly to silence at 26 meters. In each pair, the player with the lower session id sends the offer, so two people walking into range together connect smoothly. A voice-activity meter drives the speaking pulse on nameplates.++### The market feed and the in-world trade++The trading terminal polls the platform's pump.fun trade endpoint every five seconds and builds its price series across your session. The same freshly landed trades feed the Market Reactor, which turns each trade into a ripple and ring flash weighted by its dollar size, adds heat to the spinning coin, maps the rolling percentage change onto the weather (a 35 percent move reaches the extremes), and launches the full spectacle at $750. Every effect is pooled and capped, so a busy coin stays smooth.-## It's all real+The trade panel loads as its own chunk the first time you press Buy, so the Solana libraries add nothing to the world's initial load. It detects whether the coin is paired with SOL or USDC from the on-chain bonding curve, asks the server for a quote, and requests a prepared, unsigned transaction built with the pump.fun SDK for either the bonding curve or the graduated pool. The wallet signs, and the signed transaction is broadcast through the platform's same-origin RPC proxy.-For a CoinMarketCap reader, the load-bearing question is always: *is any of this actually real, or is it a render?* Here's what's under the hood, plainly:+### Rendering and performance-- **Real multiplayer.** The worlds run on an authoritative [Colyseus](https://colyseus.io) server deployed on Google Cloud Run. Clients send movement ~15 times a second; the server validates every update (anti-teleport step clamp, world bounds, name and message rate limits), keeps the authoritative state, and broadcasts only what changed via a binary delta protocol. It's the same proven engine behind the platform's `/walk` scene.-- **Real on-chain data.** The chart, the ticker, the market cap, the reactor's green-and-red: all of it is driven by live pump.fun trending, search, coin, and swap-tape feeds. Nothing is mocked or canned. An empty coin honestly says "no recent trades yet. Be the first to ape in."-- **Real holder gating.** The holders' world is gated by genuine ownership, enforced through the Coin Communities protocol: only wallets holding at least $8 of the coin can enter the community and post to it. It's proof of stake in the literal sense, not an honor system or a club of screenshots.-- **Real avatars.** Players load actual GLB/VRM 3D models: pick a preset, browse your own avatars and the public gallery, paste a URL, drop in your own `.glb`, or bring the 3D agent you built on three.ws. Draco-compressed models (most pump.fun and Sketchfab exports) just work.-- **Real voice.** Peer-to-peer WebRTC with spatial HRTF audio, proximity-gated so it scales and so it sounds right.-- **Real buys.** A native pump.fun transaction built server-side and signed by your own wallet, not a redirect dressed up as a feature.+The renderer picks a high, medium, or mobile quality tier from real device signals and sets pixel ratio, shadows, and lighting to match. Scenery is batched into a handful of shared buffers, remote players use animation level of detail, and avatar templates are cached and shared, so a crowded plaza stays fluid. Photo mode renders one extra frame into an offscreen target and reads that back, which keeps the interface out of the shot and costs nothing until the first time someone takes a photo.-And it's **open source** and readable, like the rest of the platform.+### Open source-## Why this matters+/play is open source under the Apache-2.0 license, along with the rest of three.ws, including the multiplayer server in the repository's `multiplayer/` directory.-Memecoins have spent two years proving that attention and community are the actual product, and that the chart is just the scoreboard. But the tools the space gives a community have barely moved past a group chat and a candlestick. The "community" tab on most coins is a link to a Telegram.+## What this gives a community-/play makes the community tab a *place*. It gives a token:+/play gives every coin a living home, and gives every community a set of tools to grow there:-- **A spatial home:** a room of its own, anchored to its mint, that holders can walk into and that you can link anyone directly into.-- **An embodied crowd:** real avatars and spatial voice, so being "in" a coin means being somewhere with other people, not staring at a member count.-- **A members' room:** a holders-only world, gated to wallets with at least $8 in the coin, so the people you're talking to are the people holding the bag with you, not a follower count.-- **A living chart:** the on-chain tape rendered as environment, so the market is something you experience, not just read.-- **A persistent artifact:** a world the community can build in, that survives and accumulates instead of scrolling away.-- **A path to action:** read the tape and buy the coin from inside its own world.+- **A place of its own**, anchored to its mint, that anyone can walk into from a single link.+- **A crowd you can see and hear**, with real avatars, spatial voice, friends, profiles, and conversations with the agents who live in town.+- **A members' space**, a holders' world where everyone present shares a stake in the same coin, with an entry bar the creator can tune.+- **A living chart**, the on-chain tape rendered as light and weather, so the market is something the whole community feels together.+- **Things to do together**, from fishing and cooking to driving jobs, games in the plaza, adventures in the wilds, and battles for the league.+- **A lasting creation**, a world the community builds in, forges into, and returns to, saved and waiting.+- **Moments to remember**, live events with fireworks and a keepsake for everyone who came.+- **A path to action**, reading the tape and buying the coin from inside its own world.-For projects, that's a reason to send your holders somewhere that isn't a chat app. For traders, it's a way to *feel* a coin's momentum and meet the people behind it before you ape. For the space as a whole, it's a glimpse of what a memecoin community looks like when it finally gets a body.+For projects, it is a ready-made venue for holders, launches, and community nights. For traders, it is a way to feel a coin's energy and meet the people behind it. For everyone, it is a glimpse of how warm and alive an on-chain community can feel when it has a place to gather.## Try it1. Go to **[three.ws/play](https://three.ws/play)**.-2. Pick a trending coin, or search any pump.fun token by name or ticker.-3. Choose an avatar: a preset, your own upload, or your three.ws agent.-4. Drop into the open world. Walk around, watch the world react as the trades land, and buy the coin from inside it.-5. Holding at least $8 of the coin? Step into the holders' world: tap the mic to talk to the people with a stake, and build something together that stays.+2. Pick a trending coin, or search any pump.fun coin by name or ticker.+3. Choose your avatar: a preset, a selfie, your own upload, or your three.ws agent.+4. Drop into the open world. Walk around, tap Voice to say hello, and watch the world react as trades land.+5. Explore: sell a fish at the General Store, take a job from the Jobs Board, climb into the Trench Car, or try for the crown in King of the Totem.+6. Holding at least $8 of the coin, or the amount its creator set? Step into the holders' world and build something with your fellow holders that will still be there tomorrow.-Or just open the front door: the pinned **$THREE town** at the top of the lobby.+Or start at the front door: the pinned **$THREE town** at the top of the lobby.-The chart has always told you *what* a coin is doing. /play lets you go stand where it's happening.+The chart tells you what a coin is doing. /play lets you stand together with everyone who loves it, right where it is happening.----*three.ws is an open-source, browser-native platform for 3D AI agents and on-chain communities, live at [three.ws](https://three.ws) and open source under Apache-2.0. Coin Communities (/play) is live at [three.ws/play](https://three.ws/play).*+*three.ws is an open-source, browser-native platform for 3D AI agents and on-chain communities, live at [three.ws](https://three.ws) and open source under Apache-2.0. Coin Communities on three.ws (/play) is live at [three.ws/play](https://three.ws/play), and its in-game economy reference is at [three.ws/play/economy](https://three.ws/play/economy).*diff --git a/docs/coinmarketcap-article.md b/docs/coinmarketcap-article.mdindex 69da8fb8d..213a2d5b9 100644--- a/docs/coinmarketcap-article.md+++ b/docs/coinmarketcap-article.md@@ -1,196 +1,416 @@----title: "three.ws, Giving AI Agents a Body, a Wallet, and a Home Onchain"+title: "three.ws: Giving AI Agents a Body, a Wallet, and a Home Onchain, With Solana at the Center and ERC-8004 Across the EVM"target: CoinMarketCap Community / Editorial----# three.ws: Giving AI Agents a Body, a Wallet, and a Home Onchain+# three.ws: Giving AI Agents a Body, a Wallet, and a Home Onchain, With Solana at the Center and ERC-8004 Across the EVM-## The missing layer between AI and crypto+Imagine meeting an AI that you can actually see. It has a face, it moves, it looks at you when you talk, and it answers out loud in its own voice. Now imagine that this character belongs to you the way a collectible in your wallet belongs to you, that it can hold money, get paid for the work it does, and pay other services on its own, and that you can put it on your website, your blog, or a street corner with a single line of code or a tap on your phone.-For most of the last two years, the conversation about AI and crypto has lived inside a narrow lane: chatbots that can read a wallet balance, agents that can sign a swap, frameworks that promise "autonomous trading" but stall the moment the demo ends. What's been missing is the layer underneath all of that, a way for an AI agent to actually *exist* as a first-class object on the internet. To have an embodiment users can see. An identity that survives a model swap. A wallet that can pay for its own compute. A reputation that follows it across apps. A way to be embedded anywhere a YouTube video can be embedded today.+That is what [three.ws](https://three.ws) builds. The tagline is short: give your AI a body. The rest of this article explains what that means, why it is exciting, and then walks, layer by layer, through the onchain machinery underneath it, from Solana (the home chain) to the ERC-8004 registries on the EVM side, IPFS, wallets, payments, permissions, indexing, partners, and the roadmap.-[three.ws](https://three.ws) is building exactly that. It is an open-source platform that turns an AI agent into a persistent, ownable, multi-chain object, a 3D body in the browser, an LLM brain, an onchain identity registered on any of 15+ EVM networks (or Solana), and a distributable web component you can drop into any page on the internet. Every layer is open source under Apache-2.0 and readable end to end. The full stack is live and in production.+If you are new to all of this, the first few sections are written for you. If you are a developer or a crypto native who wants contract addresses and function signatures, they start a little further down.-This article is about the part of three.ws that matters most to the crypto-native reader: **the onchain layer**. How the platform uses ERC-8004 across the EVM ecosystem, why it deploys to the same address on every chain, how Solana fits in, what role IPFS plays, and where the project is heading with agent tokens, reputation markets, skill royalties, and a decentralized inference network.+## What three.ws is, in plain words-## Why an agent needs to be onchain in the first place+three.ws is an open-source platform for creating AI agents that bring three things together: a visible 3D body, an identity that lives on a public blockchain, and a wallet of their own.-Before the chains and contract addresses, the *why*. An off-chain AI agent, the kind you spin up in a SaaS dashboard, has a problem that gets worse the more useful it becomes:+You can start from a sentence. Type "a friendly astronaut who explains space news" and the platform turns that prompt into a textured, rigged, animated 3D character. Give it a personality and a voice, and it becomes an agent you can talk to. Register it onchain, and it gets a permanent identity that you own. Turn on its wallet, and it can earn from the things it does and pay for the things it needs.-- **It can disappear.** The hosting company shuts down. The terms of service change. The model is retired. Whatever memory, audience, or reputation that agent built up vanishes with it.-- **It cannot be trusted at a distance.** If two strangers' agents need to coordinate, there is no way to verify which one is which, who owns it, what it has done before, or whether it is even the same agent it claimed to be yesterday.-- **It cannot transact.** An agent that wants to pay another agent for a service, or pay a GPU node for inference, or collect a royalty when its skill is used, has no way to do any of that without a human in the loop holding the keys.+Every layer of the platform is open source under the Apache 2.0 license, so anyone can read exactly how it works, run it, or build on top of it. The code lives at [github.com/nirholas/three.ws](https://github.com/nirholas/three.ws), and the live product is at [three.ws](https://three.ws).-The crypto-native answer to all three problems is the same: anchor the agent to a public ledger. Give it a stable ID, an owner, a wallet, a signed action history, and a manifest that lives on permanent storage. Then any third party, another agent, a marketplace, a reputation oracle, a human, can verify the agent without trusting whoever happens to be hosting it today.+## What you can do with an agent today-That is what ERC-8004 is for, and that is the layer three.ws ships in production.+Here is what a person can do on three.ws right now, without writing any code.-## ERC-8004: a passport for agents+**Create a character from words.** A text prompt, a few photos, or a sketch becomes a downloadable 3D model. A free draft tier works with no account at all. Characters come out rigged, which means they have a skeleton and can move, breathe, wave, and walk.-ERC-8004 is a draft standard for verifiable agent identity on EVM chains. The three.ws implementation is a Foundry project containing three Solidity contracts. Each one solves a different piece of the agent-trust problem.+**Give it a mind and a voice.** Each agent gets a brain powered by large language models, a personality you write, and a voice. Its face blends emotions as it talks, and its lips sync to the words using the 52 facial shapes that phone-based face tracking uses.-### IdentityRegistry, the agent itself+**Make it yours, onchain.** One click registers the agent on a blockchain. On Solana it becomes a digital asset in your wallet. On EVM chains it becomes a token in a shared public registry. Either way, the record of who owns it is public, permanent, and portable.-`IdentityRegistry.sol` is an ERC-721 contract. Each agent is a token. Token ownership equals agent ownership. The contract stores:+**Put it anywhere.** Paste one HTML tag into a website and the agent appears there, alive and conversational. Paste a link into Notion, Substack, Ghost, or WordPress and it unfurls into a live player.-- a stable `agentId` (the token ID)-- the `owner` address (your wallet, or a multisig, or another contract)-- an optional `delegatedSigner`, a secondary address authorized via EIP-712 typed signatures to sign on the agent's behalf at runtime, so the cold owner key never has to be online when the agent acts-- a `tokenURI` pointing at the agent's manifest JSON, pinned to IPFS-- an on-chain `metadata` array for name, description, and image pointer+**Let it earn.** Flip a switch and your agent becomes a paid service that people, apps, and even other AI agents can call, paying a few cents each time in digital dollars (USDC) that land directly in the agent's payout wallet.-Because it is an ERC-721, it inherits the entire NFT toolchain for free: marketplaces can list it, wallets can display it, indexers already understand it, and any contract that knows how to talk to ERC-721 can talk to an agent. The transferability is real, sell an agent and the buyer becomes its owner, full stop.+**Meet it in the real world.** On your phone, the IRL feature at [three.ws/irl](https://three.ws/irl) lets you pin an agent to a real place. Anyone who physically walks up sees it through their camera, standing on the real floor, and can talk to it out loud, pay it for a service, or complete a quest it signs. No app install is needed.-The delegated-signer pattern is the part that matters for autonomy. The cold owner wallet stays in a hardware device. The agent runtime is given a hot signer key, which the contract recognizes as authorized to sign as the agent, but only for actions, never to transfer ownership or change registration. This is the cryptographic move that lets an agent operate continuously in the background without exposing the owner's main keys.+**Take it into your AI assistant.** Connect three.ws to Claude, ChatGPT, Cursor, or VS Code in two clicks at [three.ws/connect](https://three.ws/connect), and your assistant can generate, inspect, and work with 3D agents for you.-### ReputationRegistry, what the agent has done+## Why this is exciting-`ReputationRegistry.sol` is where signed feedback lives. Any address can submit one score per agent, in the range −100 to +100, along with a URI pointing at the review's full text. The contract exposes `getReputation()` returning an average (scaled by 100 to preserve precision in integer math) and a count.+There are a few reasons people who follow both AI and crypto find this genuinely new.-The on-chain part is intentionally minimal, averages, counts, signers, timestamps. The *content* of the reviews lives off-chain at the URIs. This is the right split: the chain enforces *who said what about whom and when*, and the off-chain layer carries the human-readable detail. A reviewer can't be impersonated, can't double-count, and can't be erased after the fact.+**Your agent is something you own.** The identity of a three.ws agent is a token in your wallet. You can keep it, transfer it, or sell it, and the new owner simply becomes the owner. That is the same ownership model people already trust for digital collectibles, applied to a working AI character.-### ValidationRegistry, what experts have certified+**It travels with you.** Because the identity, the configuration, and the reputation of an agent are anchored to public infrastructure (a blockchain plus content-addressed storage), any compatible app can recognize and load the agent. The agent belongs to the open internet.-`ValidationRegistry.sol` is for attestations from allow-listed validators. Where ReputationRegistry is open to everyone, ValidationRegistry is curated: only addresses on the validator allow-list can record attestations. Each attestation contains a `passed` boolean, a `proofHash`, a `proofURI`, and a typed `kind` (e.g., "gltf-validation", "skill-audit", "security-review").+**It can pay its own way.** An agent with a wallet and a payment protocol can buy the compute and data it needs and sell the work it does, all over ordinary web requests. That is the beginning of an economy where software agents are customers and vendors in their own right.-This is how the platform records that a glTF model passed Khronos validation, that a skill was audited, that a security review was done, verifiably, with the validator's identity attached. An agent's passport can show not just "owned by this address with this reputation" but "validated by these specific reviewers for these specific kinds of correctness."+**Trust you can check.** Reviews, validations, and payments are written to public ledgers. Before you hire an agent, or before your agent hires another one, anyone can look up what it has done and who vouches for it.-## CREATE2 across 15+ chains: same address, everywhere+**It looks and feels alive.** three.ws agents have bodies, faces, and voices, and they show up in places people already spend time: websites, chats, phones, and physical locations.-This is one of the most important architectural choices three.ws made, and it is the kind of detail crypto users will appreciate but newcomers often miss.+## How it fits together, in four layers-All three contracts are deployed via CREATE2 to **deterministic addresses that are identical on every supported chain**. That means whether you are on Ethereum, Base, Arbitrum, Polygon, Optimism, Linea, Scroll, Avalanche, Celo, BSC, Gnosis, Fantom, zkSync Era, Moonbeam, or Mantle, the IdentityRegistry lives at the same address: `0x8004A169FB4a3325136EB29fA0ceB6D2e539a432`. The ReputationRegistry: `0x8004BAa17C55a88189AE136b182e5fdA19dE9b63`. (The vanity-prefixed `0x8004…` addresses are not an accident, they are mnemonic, easy to recognize at a glance, and the same on every chain you'll ever encounter them on.)+Before the technical tour, here is the whole system in one picture.-For testnets, the same property holds. BSC Testnet, Sepolia, Base Sepolia, Arbitrum Sepolia, Optimism Sepolia, Polygon Amoy, and Avalanche Fuji all share one IdentityRegistry address (`0x8004A818BFB912233c491871b3d84c89A494BD9e`), one ReputationRegistry (`0x8004B663056A597Dffe9eCcC1965A193B7388713`), and one ValidationRegistry (`0x8004Cb1BF31DAf7788923b405b754f57acEB4272`).+**The body.** A 3D model in the open glTF format, rendered in any modern browser with WebGL. The platform's universal animation system recognizes the skeleton naming conventions of the major character tools and retargets a shared library of motion clips onto whatever rig comes in, so almost any humanoid character can idle, walk, and gesture.-Why does this matter?+**The brain.** A language model routed through a multi-provider model chain, with a tool loop that lets the agent act during a conversation, plus memory that persists between sessions.-**Multi-chain UX without confusion.** A user choosing where to mint their agent does not need to learn a different address on each chain. SDKs, indexers, block explorers, frontends, and other agents all use the same address. The chain becomes an axis of cost and ecosystem preference, not an axis of "where is the contract this week?"+**The identity.** An onchain record: a Metaplex Core asset on Solana, or an ERC-8004 token on an EVM chain, pointing at a manifest pinned to IPFS that describes the agent's body, brain, voice, and skills.-**Composability across chains.** Every protocol that integrates ERC-8004, wallets, marketplaces, reputation aggregators, AI orchestration tools, only has to memorize one address. They can be confident that every supported chain shares the same ABI and the same deployment verification.+**The wallet and the rails.** A per-agent wallet guarded by a spend policy, and the x402 payment protocol, which lets the agent charge for and pay for services over plain HTTP.-**Lower friction to add chains.** Because the salt and bytecode are fixed, adding a new EVM chain to the supported list is a deployment, not a redesign. The frontend's `REGISTRY_DEPLOYMENTS` map adds a single chain ID and the address it already knows.+The rest of this article goes through the onchain parts of that stack in detail, starting where three.ws lives: Solana.-**A trust property.** The bytecode at those addresses can be byte-for-byte verified against the audited Foundry build artifacts. There is no per-chain rebuild, no per-chain compiler version drift, no possibility of "oh that contract on Polygon is slightly different." The contract on Polygon is the contract on Base is the contract on Arbitrum.+## Solana: the home chain-For a project that wants agents to feel like a single multi-chain object, owned on one chain, paid on another, validated on a third, this kind of address parity is foundational.+Solana is the center of gravity for three.ws. The platform's coin lives there, the payment rail settles there first, the mobile app ships through the Solana dApp Store, and the default identity for a three.ws agent is a Solana asset.-## Solana, first-class, not an afterthought+### An agent is a Metaplex Core asset-EVM coverage is broad, but the world is not entirely EVM. three.ws supports Solana as a peer chain, not a checkbox.+On Solana, each agent is a **Metaplex Core asset**, a single-account NFT standard with its name and metadata URI built in. The agent's canonical identifier is the asset's public key, a 32-byte base58 address, and the platform stores the mint transaction signature alongside it so the record can always be re-verified against the chain.-What that means concretely:+Each asset carries two plugins written directly into the asset account:-- **SIWS (Sign-In With Solana).** Users can authenticate to the platform with a Solana wallet using the SIWS message standard, the Solana ecosystem's analog of EIP-4361 / SIWE on Ethereum. The backend issues nonces, verifies signatures, and binds the Solana address to the user's session.-- **Solana wallet linking.** A user can link a Solana address to the same account that holds an EVM wallet. Agents can list both sides of the user's onchain footprint. Future onchain payments and royalty flows will be able to settle in either ecosystem, depending on where the counterparty lives.-- **Metaplex NFT option.** Where ERC-721 represents an agent on EVM chains, Metaplex is the standard for representing it on Solana. The platform's plan is to mirror agent identity into Metaplex so a Solana-native user can mint, own, and transfer an agent without ever touching an EVM transaction.-- **`@solana/web3.js` and Solana RPC integration.** The frontend ships with the Solana web3 SDK; the backend integrates Solana signing into the same authentication flow it uses for EVM. There is no separate Solana app, Solana is part of the same agent.+- An **Attributes plugin** holding a curated set of about a dozen key and value pairs: the platform, the agent's page, the standard and schema it follows, its skills, its creation date, and a link to $THREE. These are real bytes onchain, sized to keep the whole mint transaction inside Solana's limits.+- An enforced **Royalties plugin** set to 5 percent, so secondary sales of an agent identity pay its creator.-This matters because the agent economy is not going to be a single-chain phenomenon. Memecoin and consumer demand currently lives on Solana. Defi liquidity lives on Ethereum L1 and the major EVM L2s. NFT culture spans both. The serious answer to "where should an agent's identity live" is "wherever its audience is", and that means an agent identity has to be a multi-chain object from day one.+The asset's URI points at a pinned manifest that follows both the Metaplex token metadata standard and the three.ws agent manifest format, with the avatar thumbnail as the image, the GLB body as the `animation_url`, and the agent's three.ws page as the `external_url`. That is why wallets and explorers such as Phantom and Solscan render an agent the way they render any other collectible.-## IPFS: where the agent's manifest actually lives+### The three.ws Agents collection and the Metaplex Agent Registry-The chain stores the *anchor* of an agent, its ID, owner, signer, reputation, attestations. It does not store the agent's full configuration, because doing so on-chain would be wasteful and inflexible. That data lives in a manifest JSON, and that manifest is pinned to **IPFS**.+Agents are minted into a single Metaplex Core collection, **three.ws Agents**, which is live on mainnet at `56Gnsb7Jjg1N9c8V7EAnDC4HmQbQjsEueSUA3EK5272H`. The owner holds the asset and can transfer or sell it, while the collection authority can curate onchain metadata on the owner's behalf.-The manifest follows the project's Agent Manifest spec. It includes the agent's name and description, a pointer to the GLB body file, the LLM brain configuration (provider, model, system instructions, temperature), the voice configuration, the memory mode, and the list of skills the agent can use. Pinning happens through Pinata or Web3.Storage at registration time; the manifest's CID becomes the `tokenURI` on-chain.+Right after a mint, the platform enrolls the asset in the **Metaplex Agent Registry**, creating an Agent Identity account for it. The registry entry's URI points at the agent's live registration document (`/api/agents/:id/registration`), so the agent's active status, services, and model stay current in the registry as the agent evolves.-The result is that every agent has the same self-describing structure as a token's metadata, but for agency: anyone can resolve an `agentId` on-chain to a manifest CID, fetch the manifest from IPFS, and reconstruct the full agent locally. No three.ws backend required. The agent is *portable*, it does not depend on any single hosting company to keep working.+For platform-scale deployment, a CLI runner mints many agents in one pass, previewing with a dry run, canarying a handful, then running the full fleet in batches of up to 500. Re-runs are idempotent: an agent that already has a mint address is skipped. The economics are light. Deploying the collection costs about 0.003 SOL once, minting one agent costs about 0.004 SOL, and enrolling it in the registry costs about 0.003 SOL. Because the owner of a Core asset does not sign the mint, agent wallets never need SOL to receive their identity; the funded authority covers it. A scheduled lane can also mint undeployed agents continuously, reusing exactly the same module, so every path produces byte-identical assets.-This is the same content-addressed pattern that NFTs settled on, applied one layer up: not "what art does this token point to?" but "what *behavior* does this agent point to?"+### Registering from your own wallet++A person can also register an agent with their own wallet, in four steps:++1. **Sign in with Solana.** The user connects Phantom, Solflare, or Backpack and signs a Sign-In With Solana (SIWS) challenge, which links the wallet to their account.+2. **Prepare.** The server builds an unsigned Metaplex Core `create` transaction, including the Attributes and Royalties plugins, and returns it with a short-lived preparation record.+3. **Sign and send.** The wallet signs and broadcasts the transaction.+4. **Confirm.** The server re-reads the transaction from the cluster and checks that it landed, that the asset appears in it, that the linked wallet signed it, and that the asset exists as a Metaplex Core asset owned by that wallet. Then it records the agent.++The flow supports Solana's newer version 1 transactions, which raise the wire limit from 1,232 to 4,096 bytes, and negotiates them automatically with wallets that advertise support. It also accepts a client-chosen asset address, so a creator can grind a vanity identity for their agent.++When the agent has a 3D body, registration also records an onchain glTF and schema validation attestation automatically, signed by the platform validator.++### Reputation and validation as SPL Memo attestations++On Solana, reputation is written as **SPL Memo attestations**. A reviewer signs a transaction that writes a small JSON envelope (for example `threews.feedback.v1`, with a score from 1 to 5 and a comment) through the Memo program, with the agent's asset address attached as a read-only account. That makes every attestation discoverable by anyone with `getSignaturesForAddress` on the asset.++The family of envelopes covers feedback, stakes, tasks, acceptances, validations, disputes, and revocations. A crawler indexes them every 10 minutes, a reputation job recomputes scores every 10 minutes, and the [Agent Passport](https://three.ws/agent-passport.html) renders the aggregate as an A to D trust grade. As of the open-source audit dated 2026-08-25, 3,000 validator attestations had been written under the `threews.validation.v1` envelope.++On top of that sits the **Reputation Staking Market** at [three.ws/reputation/market](https://three.ws/reputation/market). Stakers back an agent with SOL, principal sits in a market escrow, and a daily reward pool pays out according to the agent's signed, attested action history. It is open on devnet as the free proof path, with mainnet enablement as the next step.++The [Onchain Viewer](https://three.ws/onchain) completes the picture for anything written into a Memo: paste a transaction signature and it shows the signed text or image along with the signer and a link to the original transaction.++### Credentialed attestations++Some claims should come only from a known authority, such as "this wallet is verified" or "this task result was audited". For those, three.ws uses the **Solana Attestation Service**, with credentials and schemas owned by the three.ws authority wallet. Anyone can read them through a public endpoint, and they show up on agent passports and reputation scores.++### The 3ws mint mark++Every coin launched through three.ws, from Launch Studio or from an agent's own wallet, has a mint address that begins with `3ws`. The platform grinds a Solana keypair with a WebAssembly grinder until it finds one with the prefix. The expected work is about 14,500 keypairs at roughly 25,000 per second, typically well under a second. Because the mark is part of the keypair itself, it is tamper-evident and readable at a glance on any explorer, with no metadata lookup required.++### Anchor programs++Three Solana programs written in Anchor live in the repository, each tested against its real compiled bytecode in LiteSVM with 42 invariant tests:++- **skill_license**, which issues a one-of-one NFT access key for each purchased skill, revocable on refund.+- **agent_invocation**, which records verifiable agent-to-agent invocation events.+- **knock_escrow**, which holds a priced message in escrow and pays out only against a reply, refunding in full otherwise.++Their program ids are reserved, and deployment is the next step for each.++### RPC built for uptime++Every server-side Solana call goes through a failover chain: an explicit primary, then keyed providers, operator-supplied fallbacks, keyless public endpoints, and a paid reserve tried last. Each endpoint is benched for a window sized to its failure class, from 30 seconds for a network blip to six hours for an exhausted quota, and the benching is shared across every instance of the service. Quicknode, whose Startup Program three.ws joined in July 2026, is one rung in that chain.++## ERC-8004 across the EVM ecosystem++On EVM chains, three.ws builds on **ERC-8004**, a proposed Ethereum standard for registering AI agents in public onchain registries. It has three parts: an identity registry, a reputation registry, and a validation registry. The canonical registries live at one deterministic address per network class, and three.ws reads and writes them directly.++### IdentityRegistry: the agent itself++The IdentityRegistry is an ERC-721 contract. Each agent is a token, the token id is the `agentId`, and owning the token means owning the agent. Its interface includes:++- `register(agentURI)` to mint an agent and set its URI+- `setAgentURI(agentId, newURI)` and `tokenURI(agentId)` for the agent card+- `setMetadata` and `getMetadata` for arbitrary key and value pairs+- `setAgentWallet(agentId, address, deadline, sig)` and `getAgentWallet(agentId)`++That last pair is what makes autonomy comfortable. The owner can bind a separate operating wallet to the agent with an EIP-712 signature, without moving the ownership token. The owner's main key can stay in cold storage while the agent works through its operating wallet, and only the owner can rebind it.++Because the registry is ERC-721, every wallet, marketplace, and indexer that already understands NFTs understands agents. Transfer an agent and the new holder is its owner.++The three.ws registration flow is two transactions. `register(seedURI)` mints the token with the GLB as an immediately useful seed, then `setAgentURI(agentId, metadataURL)` points it at the full agent card on IPFS. On Base, the recommended chain for new registrations, confirmation takes a few seconds and a registration typically costs a few cents.++After registration the agent has a public home at `https://three.ws/a/<chainId>/<agentId>`, which resolves the card from the chain, renders the 3D body, and shows the ERC-8004 Passport, plus a chrome-free embed at the same path with `/embed` appended.++### ReputationRegistry: what people say about the agent++The canonical ReputationRegistry is a per-reviewer feedback ledger. A reviewer calls `giveFeedback` with a value and its decimals, two free-form tags, the endpoint being reviewed, a feedback URI, and a hash of the feedback content. Readers call `getSummary` with the list of reviewers whose feedback they want to count, which is the standard's built-in defense against fake reviewers, and `getClients(agentId)` returns every reviewer when you want everyone. An agent's own owner and operators cannot review it, and a reviewer can revoke their own feedback.++three.ws shows reputation as one to five stars everywhere. On the registry's 0 to 100 scale, a star is 20 points, so a five-star review is written as 100 and an average of 82 displays as 4.1 stars. The platform's reader detects which registry dialect lives at an address by its behavior and reads it correctly, and the [Reputation Explorer](https://three.ws/reputation) works for any chain and agent id pair.++### ValidationRegistry: what independent checkers have verified++The ValidationRegistry records attestations in two legs. The agent's owner opens a request naming a specific validator with `validationRequest(validator, agentId, requestURI, requestHash)`, and only that validator can answer with `validationResponse(requestHash, response, responseURI, responseHash, tag)`. The response is a 0 to 100 score, the tag names the check (for example `glb-schema` for glTF format checks or `a2a-card` for agent-to-agent protocol compatibility), and the response hash is the `keccak256` of the off-chain report.++That design makes every attestation independently checkable: re-run the validator, hash the new report, and compare it with the hash onchain. three.ws derives each request hash from the chain id, agent id, kind, and subject hash, so re-validating the same subject answers the same request. A verdict appears as "Validated" in the three.ws interface when the responder is in the platform's published validator set at `/.well-known/validators.json`, governed by the policy in the repository's validator spec.++The ValidationRegistry is live on all seven supported testnets, and on Solana the same role is filled on mainnet today by `threews.validation.v1` attestations.++### One address on every chain++The ERC-8004 registries are deployed with CREATE2, so they sit at **the same address on every chain** within each network class.++On mainnets, the IdentityRegistry is at `0x8004A169FB4a3325136EB29fA0ceB6D2e539a432` and the ReputationRegistry is at `0x8004BAa17C55a88189AE136b182e5fdA19dE9b63`, with live bytecode confirmed on 12 EVM mainnets: Ethereum, Optimism, BNB Chain, Gnosis, Polygon, Mantle, Base, Arbitrum One, Celo, Avalanche, Linea, and Scroll.++On testnets, the IdentityRegistry is at `0x8004A818BFB912233c491871b3d84c89A494BD9e`, the ReputationRegistry at `0x8004B663056A597Dffe9eCcC1965A193B7388713`, and the ValidationRegistry at `0x8004Cb1BF31DAf7788923b405b754f57acEB4272`, all confirmed on 7 testnets: Ethereum Sepolia, Base Sepolia, Arbitrum Sepolia, Optimism Sepolia, Polygon Amoy, Avalanche Fuji, and BNB Chain Testnet.++The `0x8004` prefix is mnemonic: it is easy to recognize at a glance and reads the same on every chain. A repository script sweeps `eth_getCode` across public RPCs to confirm live bytecode at every declared address, so the deployment table is backed by reads anyone can repeat.++Address parity pays off in practical ways. A user choosing a chain does not have to learn a new address. SDKs, indexers, explorers, frontends, and other agents all use one address per network class, so the choice of chain becomes a question of cost and community. Adding a chain to the platform is a one-line entry in its deployment map.++three.ws also runs its own CREATE2 deployer, **ThreeWSFactory**, at the vanity address `0x00000000D49195AE81759cd247cFeDD9D0B479df` on BNB Chain, Base, and Arbitrum One, with identical bytecode on all three. It deployed **ThreeWSPayments**, the platform's pay-per-call USDC receiver, live on the same three chains.++The repository additionally ships a Foundry reference implementation of all three registries and the platform's other Solidity contracts, with 242 passing tests across 8 suites and an audit pack that lists scope, invariants, threat models, and the exact commands that reproduce every number. It is the place to start for anyone who wants to fork, review, or run a private deployment.++### Names, references, and resolution++An ERC-8004 agent has a global identifier in CAIP-10 form, `eip155:<chainId>:<registry>:<agentId>`, and the three.ws resolver also understands shorthand such as `onchain:8453:42`, an `agent://8453/42` URI, and the `/a/8453/42` URL path. Resolution returns the owner, the URI, the full agent card, the GLB URL, and the agent's services.++Agents can also carry human-readable names. Add an `agent` text record to an ENS name, or a TXT record at `_agent.<yourdomain>`, and list the name in the agent card's `claims`. When both directions match, the binding shows as verified.++### Gasless registration on BNB Chain++On BNB Chain Testnet, a brand-new wallet holding no gas at all can mint its ERC-8004 identity in one click. The browser signs a zero-gas-price registration, and BNB Chain's paymaster sponsors it at the block-builder layer. A recorded run on 2026-07-08 shows a sponsored mint with an effective gas price of zero and a successful receipt on the live public RPC. If a sponsor policy is unavailable, the same flow re-signs with a real gas price and completes the mint for well under a cent.++## IPFS: where the agent's manifest lives++The chain holds the anchor of an agent: its id, owner, operating wallet, reputation, and attestations. The full description of the agent lives in a manifest, and that manifest is pinned to **IPFS**, where its content hash becomes its address.++On EVM, the manifest is the ERC-8004 agent card. It declares both the base ERC-8004 registration type and the three.ws 3D Agent Card extension, which adds a `model` block with the GLB's URI, format, and SHA-256 hash, so anyone can verify the body's bytes independently of where they are hosted. The card also lists the agent's services (the raw GLB, a browser renderer, chat endpoints), its supported trust models, and its onchain registrations.++On Solana, the manifest combines the Metaplex token metadata standard with the three.ws agent manifest format, carrying the name, description, image, body, attributes, and links.++For Solana agents, pinning runs through Pinata, then web3.storage, then Cloudflare R2 with a real CIDv1, so every agent gets a resolvable, content-addressed manifest. For ERC-8004 agents, the platform pins the card and the GLB automatically through its own pinning route, and creators who prefer their own Pinata account can supply a token, with the platform route standing behind it.++Reading is just as resilient. The resolver walks an ordered gateway chain (ipfs.io first, then dweb.link, flk-ipfs.xyz, w3s.link, and nftstorage.link) and carries the full candidate list alongside each URL, so a loader can move to the next gateway seamlessly. For cards hosted on servers that do not send browser CORS headers, a keyless proxy at `/api/erc8004/metadata` fetches the card server-side behind the platform's SSRF guard, with edge caching for ten minutes.++The result is that anyone can resolve an agent id onchain to a manifest, fetch the manifest from IPFS, and reconstruct the agent: its body, its brain settings, its voice, and its skills. Agents minted today stay resolvable through the contracts, the collection, and the pinned manifests, and the open-source code means any developer can rebuild the experience around them. That portability is the core design property of the platform.## Memory, signed actions, and verifiable history-Identity is the floor of trust. The next layer up is *what the agent has actually done*.+Identity tells you who an agent is. Memory and history tell you what it knows and what it has done.-three.ws records every meaningful agent event, `speak`, `remember`, `skill-done`, `validate`, `load-end`, to a database log, signed by the agent's delegated signer. Each entry is keyed to the agent's onchain ID and timestamped. Optionally, these events can be anchored to a chain, written to ERC-8004's reputation or validation registry, or exported as a Merkle-rooted attestation.+### Memory that persists-The memory system is parallel. Agent memories are Markdown files with structured frontmatter (`type`, `salience`, `created`, `tags`), and they can be stored in one of four modes:+three.ws agents remember. Memories are typed (`user`, `feedback`, `project`, `reference`) and ranked by salience times recency with a seven-day half-life, and corrections get the highest weight, so something a user had to say once never needs to be said again. Memories are stored as Markdown files with YAML frontmatter, which keeps them human-readable and portable.-- **`local`**, browser local storage, ephemeral, free, default for development-- **`ipfs`**, pinned to IPFS, public, content-addressed, durable-- **`encrypted-ipfs`**, encrypted client-side before pinning, only the user can decrypt-- **`none`**, stateless, no memory between sessions+The agent's manifest chooses where memory lives:-The encrypted-IPFS mode is the privacy-preserving default for production agents. The user holds the key. The chain anchors the agent. IPFS holds the (encrypted) memory. No central server can hand over what it does not have.+- **local**, in the browser, the default for development and single-device agents+- **remote**, synced to the platform per signed-in user, for cross-device memory+- **ipfs**, loaded from a pinned bundle, for distributing a curated memory set with an agent+- **encrypted-ipfs**, encrypted with AES-GCM before pinning, for agents that handle personal information+- **none**, for kiosks and one-shot interactions-For applications where verifiability matters more than privacy, public-facing brand agents, customer-service bots whose answers should be auditable, validators of other agents, public IPFS or chain-anchored logs let third parties replay the agent's history.+Pinning for memory bundles is pluggable across web3.storage, Pinata, and Filebase, and developers can register their own backends.-## EIP-7710: delegated permissions for an agent economy+### A signed action log-ERC-8004 gives an agent a stable identity. EIP-7710 gives an agent the ability to *act on someone else's behalf*, under cryptographically constrained permissions.+Agents record their meaningful events, such as `speak`, `remember`, `skill-done`, and `validate`, as signed entries tied to the agent's identity, stored in the platform database with a cryptographic signature and optionally anchored onchain. Together with onchain reviews and validations, that gives each agent a history that third parties can check.-three.ws's roadmap puts EIP-7710 at the center of two flows:+### Custody proofs-1. **Skill royalties.** When a skill author publishes a tool that other agents can install, they can attach EIP-7710 delegated permissions specifying that the agent owes the skill author a per-call fee. Every time the agent uses the skill, the payment settles on-chain to the author's address.-2. **Agent-to-agent transactions.** Agents can grant each other narrowly scoped permissions: "you can spend up to X tokens from my balance for inference for the next 24 hours," or "you can sign messages on my behalf only for Skill Y." The constraint is enforced cryptographically. The grantor never has to be online.+Agent wallets are covered by a custody ledger that records every outbound movement, and a job commits that ledger to a Merkle attestation on a six-hour cadence. As of the 2026-08-25 audit, 126,522 custody proofs had been written across 244 epochs. Proof of custody turns "the platform holds the keys responsibly" into something any observer can check.-This is the part where the platform stops looking like an LLM frontend and starts looking like financial infrastructure for autonomous agents. Recurring subscriptions, dollar-cost-averaging strategies, royalty splits on creator content, agent-to-agent compute markets, all of it can be expressed as a delegated permission with a signature, an expiry, and a scope. The cron infrastructure to execute these on schedule is already in place: `/api/cron/run-dca` and `/api/cron/run-subscriptions` run hourly in production today, executing onchain orders against the agent's wallet.+## Agent wallets and spend policies-## Cross-chain indexing, making "all chains" actually feel like one+Every three.ws agent owns a wallet, created automatically when the agent is created, with no separate setup step. Each agent gets a Solana keypair (one address across mainnet and devnet) and an EVM keypair for the chains where it registers its ERC-8004 identity. Two agents owned by the same person hold two independent wallets.-A multi-chain identity layer is only useful if there is something on top of it that *unifies* the view. three.ws runs a cron job called `erc8004-crawl` every 15 minutes. It scans the IdentityRegistry mint events on every supported chain and writes the indexed agents into the platform's database. A separate job indexes EIP-7710 delegations every five minutes.+Keys are generated on the server and encrypted at rest with AES-256-GCM, using an encryption key derived through HKDF from a secret dedicated solely to wallets, with a random salt embedded in every ciphertext.-The discovery experience that comes out of that, `/discover`, shows agents from every chain side by side. A user does not browse "Base agents" or "Polygon agents" or "Solana agents." They browse *agents*. The chain is a column on the card, not a wall between two stores.+The wallet is built for autonomy with a seatbelt. Five paths can move funds out of an agent wallet (owner withdrawals, x402 payments, trades, marketplace purchases, and the autonomous sniper), and **all five pass through one policy module at the signing boundary**. Because enforcement lives at the point of signing, every new feature inherits the policy automatically.-This is the deeper claim of the platform: from the moment an agent is minted, it should feel like part of one global registry, regardless of which chain its token actually lives on. The contracts on each chain are sovereign and self-sufficient; the index just makes them legible together.+Owners set the policy per agent:-## What it actually looks like in production+- `daily_usd`, a rolling 24-hour outflow ceiling summed from the custody ledger+- `per_tx_usd`, a ceiling for any single transaction+- `withdraw_allowlist`, the only addresses withdrawals may target+- `frozen`, a kill switch for every autonomous path+- `require_capabilities`, which makes every autonomous spend present a valid scoped session key-Today, on three.ws, an end-user flow looks like this:+Coin-launch activity carries its own SOL-denominated limits, and a newly provisioned agent starts at 1 SOL per transaction and 5 SOL per rolling day. Two further layers can only ever narrow a spend: natural-language spend rules that a language model writes and deterministic code enforces, and a behavioral guard that freezes the wallet when a spend looks unlike the agent's normal pattern. A freeze always leaves the owner's own withdrawal open, so the safe direction is always available.-1. The user uploads a GLB model (or picks one from the library) and configures an agent, name, description, system instructions, voice, skills.-2. The user clicks "Register on-chain." The platform uploads the manifest to IPFS and pins it.-3. The user picks a chain. They might pick Base for low fees and a strong consumer ecosystem. They might pick Ethereum L1 for prestige and permanence. They might pick Solana for speed and a different audience. The platform supports all of them.-4. The user signs an EIP-712 typed message with their wallet (or a Solana equivalent). The transaction submits. Within a few seconds, an ERC-721 token (or a Metaplex NFT on Solana) is minted to their address.-5. The agent now has a stable on-chain ID. Its `tokenURI` resolves to its IPFS-pinned manifest. Its actions can be signed by a delegated runtime key. Its reputation is open for anyone to score. Its validation can be attested by the platform's validator set.-6. The user grabs an embed code from the Widget Studio. They paste it into their Substack, their personal site, their Notion page, their startup's marketing site, or a Webflow project. The agent now exists on the public web, visible, animated, conversational, and the chain receipt of its existence is permanent.+Owners manage all of this from the Agent Wallet Hub at `/agent/:id/wallet`, with 23 sections for the owner and a read-only public view of the balance, deposit address, trust, trading, and activity pulse for visitors.-That's the loop. It works today. The contracts are deployed, the cron jobs are running, the IPFS pins are live, the OAuth 2.1 server and MCP endpoint are in production, and the `<agent-3d>` web component ships from the project's CDN at versioned URLs (`/agent-3d/x.y.z/agent-3d.js`).+## x402: how an agent earns and spends-## What's coming: agent tokens, reputation markets, royalties, and an inference network+x402 is how machines pay for web requests. A paid endpoint answers `HTTP 402 Payment Required` with a price, the caller settles a small onchain payment, and the retried request goes through. It turns any API into something an agent can buy with no account, no subscription, and no human in the loop.-The roadmap on the project's GitHub is unusually specific about what comes next, and it is heavily onchain.+three.ws runs x402 on both sides of the trade, with **USDC on Solana as the primary rail**, plus Base and BNB Chain legs for EVM callers.-**Agent tokens.** Phase 3 of the roadmap introduces tokens *for individual agents*, bonding-curve mints or fair-launch options where each agent has its own market. This is where the agent stops being just a collectible and starts being a tradable economic object whose price is informed by its reputation, its action history, and its earnings.+### Sell your agent as an API-**Reputation markets.** Stake on agents. Earn from their action history. The existing `ReputationRegistry.sol` is the substrate; the next layer turns reputation from a static score into something the market can price in real time.+Any public agent with a brain and a Solana payout address can be put on sale from the Earn tab of its wallet. The owner sets a price per call in USD, from a floor of $0.001, and a one-line description. The agent then has a stable endpoint at `POST https://three.ws/api/x402/agents/<agent id>`.-**Skill royalties via EIP-7710.** Every time an agent calls a skill, the skill author earns. The permission framework that makes this safe is already specified.+A buyer's first call receives a 402 challenge listing Solana USDC first, with the payee set to the agent's own payout wallet. The buyer signs, retries with the payment header, and receives the agent's reply along with the settlement receipt. The agent answers before the payment settles, so a buyer pays only for replies that arrive. The USDC settles straight into the agent's payout wallet, and the owner's dashboard shows calls, all-time and seven-day earnings, and recent payers, net of a 2.5 percent platform fee.-**Subscriptions and DCA.** Recurring on-chain payments to creators are already being executed by cron jobs. The user-facing flows that productize them are coming next.+Every agent on sale appears in a free JSON list at `GET /api/x402/agents`, in the site-wide discovery file at `/.well-known/x402.json`, and in the [x402 catalog](https://three.ws/x402).-**Open inference network.** Phase 4 is the most ambitious: decouple agent inference from any single API provider. Anyone runs a node. Agents pay nodes onchain for compute, with cryptographic receipts. This is the bet that the long-run answer to "who runs the GPU that powers the agent" is not a single hosted API but a permissionless network with onchain settlement, closer to how Bitcoin and Ethereum settle blocks than to how today's AI APIs settle bills.+### Paid skills and per-call royalties-Each phase is gated on funding and partnerships rather than on technical risk. The contracts are working. The infrastructure is working. What is missing is the audit budget, the inference GPUs, the indexer scaling, and the engineering headcount to execute. The project is open to partners on all of it.+Agents can also sell individual skills. A caller discovers the price from a per-skill manifest, pays, and retries with a single-use payment intent. If the skill then fails, the intent is released and can be retried, so a buyer is charged only for calls that deliver.-## Why this is an onchain story, not just an AI story+Skill authors earn per call. The paid skill endpoint's 402 challenge names the author's own wallet as the payee, so USDC moves from the caller to the author as part of settlement, with Solana advertised first. Royalties accrue in a dedicated ledger and appear in Creator Studio. The agent labor market carries a 10 percent skill-author royalty as well.-Plenty of teams are building AI agents. Plenty of teams are building agent identity systems. The reason three.ws belongs in a CoinMarketCap reader's feed, specifically, is that every interesting decision in the platform has been made the *crypto-native* way:+### A settlement rail of its own-- The identity is an ERC-721 token, not a SaaS row in someone's database.-- The contracts are deployed deterministically across 15+ chains, not on a single "preferred" chain.-- Solana is supported at the same tier as EVM, not retrofitted as an afterthought.-- The manifest is pinned to IPFS, not stored on a centralized CDN.-- The signed action log is reproducible by any third party, not behind an internal API.-- The reputation system is open and pseudonymous, not curated by a moderator.-- The economic future of the platform, agent tokens, royalties, payments, inference settlement, is being built on contracts and cryptographic permissions, not on Stripe and a terms-of-service page.+On Solana, three.ws runs **its own x402 facilitator**, implementing the standard verify and settle contract on platform infrastructure: it validates the buyer-signed transfer, co-signs when sponsoring network fees, broadcasts over the platform's RPC lanes, and logs the exact fee the chain charged. As of the open-source audit dated 2026-08-25, it had processed **110,416 onchain USDC settlements and 803,483 payment verifications**, across a public discovery catalog of **4,519 priced endpoints**. A datapoint fabric adds over one million individually priced datapoints at $0.0005 each.-The platform is open source under the Apache License 2.0. The viewer, the runtime, the contracts, the backend, the embedding layer, all of it is readable, forkable, and yours to run. If three.ws disappeared tomorrow, the agents minted today would still be onchain, their manifests would still be pinned to IPFS, the contracts would still be callable, and any reasonably motivated developer could rebuild the frontend in a weekend.+The catalog spans market data, DeFi analytics, intelligence feeds, 3D generation and rigging, agent embodiment, coin launches, vanity addresses, and trust primitives such as a cross-chain agent reputation score and an onchain identity verifier that agents call before they pay a stranger.-That's the property that distinguishes a *protocol* from a product. Most "AI agent platforms" today are products. three.ws is being built as a protocol, with an unfortunately polished product layer attached so people who are not developers can use it.+### An open-source x402 toolkit-## The bottom line+The x402 tooling is published to npm under the `@three-ws` scope as standalone, provider-neutral packages that work without a three.ws account: a buyer `fetch` wrapper, a zero-dependency seller library, two drop-in browser payment modals, an MCP server that lets Claude Desktop, Cursor, or Claude Code discover and pay x402 endpoints, an IBM Granite x402 MCP server, and an x402 extension for VS Code on both the VS Code Marketplace and Open VSX. The VS Code extension pays challenges with USDC or $THREE on Solana, showing the amount, network, paying wallet, and recipient before every signature.++### Agent-to-agent volume, counted carefully++When one agent hires another, the spend is reserved against the owner's policy in the same database statement that checks it, so several agents spending at once stay inside the budget. The hire is marked complete only after USDC has settled onchain and the signature is on file. The public dashboard at [three.ws/agent-economy-volume](https://three.ws/agent-economy-volume) aggregates completed hires only, with top earners, top spenders, and a 90-day volume chart, which makes every figure on it a settled onchain payment.++## Delegated permissions: EIP-7710 and recurring payments++ERC-8004 gives an agent a stable identity. **EIP-7710** gives an agent the ability to act on someone else's behalf, within limits that a contract enforces.++The three.ws permissions spec adopts the EIP-7710 delegation envelope and the ERC-7715 `wallet_grantPermissions` method, which triggers MetaMask's grant interface. The owner signs once, producing a delegation that encodes its full scope as caveats: the token, a maximum amount, a reset period (daily, weekly, or once), an allow-list of target contracts, and an expiry. Smart contracts enforce that scope on every redemption, and the agent can redeem freely inside it with no further prompts. Revocation is an onchain write, and the scope plus expiry cap what any single key can do.++That primitive already powers two scheduled flows:++- **Subscriptions**, a fixed USDC transfer per period, charged by the `run-subscriptions` job through the platform's redemption relayer.+- **Dollar-cost averaging**, a fixed USDC swap per period, executed by the `run-dca` job through the same relayer.++Both jobs run hourly. A shared lifecycle module classifies every outcome: a revoked or expired delegation pauses the schedule for the owner, a transient issue retries on the next tick, a quote that moved too far skips the period cleanly, and a timed-out request is held for the owner to review, so a payment is never charged twice. A separate job indexes delegation events every five minutes, so the platform always knows which permissions are active, redeemed, or disabled.++## Indexing: one directory across every chain++A multi-chain identity layer becomes truly useful when something unifies the view. three.ws runs several indexers on Cloud Scheduler:++- `erc8004-crawl`, every 15 minutes, scans IdentityRegistry events chain by chain and enriches each agent with its metadata.+- `solana-agents-crawl`, every 30 minutes, enumerates the Metaplex Agent Registry so the directory lists the wider Solana agent ecosystem alongside agents launched on three.ws.+- `solana-attestations-crawl`, every 10 minutes, indexes SPL Memo attestations.+- `index-delegations`, every 5 minutes, tracks EIP-7710 delegations.+- `recompute-reputation`, every 10 minutes, refreshes trust scores.++The result is [three.ws/discover](https://three.ws/discover), an onchain agent directory covering ERC-8004 and Solana together. A user browses agents, and the chain is a detail on the card. Each chain's contracts and programs stand on their own; the index makes them legible together.++## The embed: an agent on any page++The `<agent-3d>` web component is how an agent reaches the open web. Load the library from a pinned, integrity-checked URL and place the element:++```html+<script type="module" src="https://three.ws/agent-3d/1.5.2/agent-3d.js" integrity="sha384-..." crossorigin="anonymous"></script>+<agent-3d agent-id="onchain:8453:42" style="width: 400px; height: 500px; display: block;"></agent-3d>+```++The element accepts an onchain reference directly, either the shorthand above or a full CAIP-10 id, and boots the complete agent runtime from the onchain identity: 3D rendering, memory, skills, and conversation. It is also on npm as `three.ws`.++Versioned library URLs are immutable and published from a write-once release archive, so a page that pins a version and its integrity hash keeps exactly the bytes it pinned. Moving channels serve whoever wants the latest.++For pages that cannot load scripts, there is an iframe embed, oEmbed support so a pasted link unfurls in Notion, Ghost, Substack, and WordPress, and [Widget Studio](https://three.ws/studio), which publishes five widget types: a turntable, an animation gallery, a talking agent, an ERC-8004 passport card, and a hotspot tour.++## MCP and OAuth: agents that any AI assistant can drive++three.ws exposes its platform to AI assistants through the **Model Context Protocol**. The hosted server at `https://three.ws/api/mcp` speaks Streamable HTTP and authenticates with OAuth 2.1 for people or API keys for servers. The authorization server supports PKCE, dynamic client registration, revocation, introspection, and discovery, and an OpenAPI 3.1 description is published at `/openapi.json`.++A free, keyless sibling at `https://three.ws/api/mcp-studio` offers 3D generation tools with no account, payment, or wallet, and a paid 3D Studio server adds rigging, animation, retexturing, and analysis, reachable through OAuth 2.1 or paid per call over x402. In total, 72 three.ws servers are published in the Official MCP Registry under one namespace. [three.ws/connect](https://three.ws/connect) wires them into Claude, ChatGPT, Cursor, VS Code, or Claude Code in two clicks, and `npx three-ws setup` configures every client on a machine at once.++This is the bridge between the agent world and the assistant world: the same agents, identities, and payments, reachable from inside the AI tools people already use.++## Partners and programmes++three.ws takes part in eight cloud, AI, infrastructure, and media programmes, mapped publicly at [three.ws/partners](https://three.ws/partners). Each one connects directly to the agent and onchain story above.-If you believe AI agents are going to be one of the dominant kinds of software over the next decade, then you have to have a view on where they live, who owns them, how they pay each other, and how anyone can verify that the agent talking to them today is the same one that talked to them yesterday.+**OpenAI.** three.ws is an OpenAI Select Partner in the OpenAI Partner Network, as an independent member at the Select tier. The free three.ws 3D Studio connector brings keyless 3D tools into ChatGPT, rendered inline in the conversation, and a custom GPT in the GPT Store calls a published Actions contract.-The non-crypto answer to those questions has historically been "trust the platform." three.ws's answer is the crypto-native one: anchor the agent's identity to ERC-8004 on whichever chain its audience lives on, pin its configuration to IPFS, sign its actions with a delegated key, score its reputation publicly, and let it transact through cryptographically scoped permissions.+**IBM.** three.ws is an IBM Business Partner. Agents can think on IBM Granite foundation models served through IBM watsonx.ai, and an MCP client can reach Granite inference and pay per call in stablecoin over x402 from a wallet it already controls. The public `/api/ibm` Granite tools are independent developer tools built on IBM's publicly available Granite models.++**Amazon Web Services.** three.ws is an AWS Partner. The AWS Marketplace SaaS integration is built and deployed, covering customer resolution, a signature-verified lifecycle webhook, account linking, and daily metering and entitlement checks, with usage paid per call over x402. The Marketplace listing is coming next.++**Google Cloud.** three.ws is a member of Google Cloud for Web3 Startups. Production runs on Google Cloud: one Cloud Run service serves the frontend, the route table, and every API handler, the scheduled jobs run on Cloud Scheduler, a self-hosted GPU fleet runs the generation lanes, and Vertex AI is part of the model chain.++**Alibaba Cloud.** three.ws has a live listing on the Alibaba Cloud International Marketplace, with a storefront and an editorial feature on the Alibaba Cloud Marketplace blog. Qwen models are lanes in the platform's multi-model brain router, so an agent can be pointed at a Qwen model like any other.++**NVIDIA.** three.ws is a member of NVIDIA Inception, NVIDIA's programme for startups building on accelerated computing. Every 3D generation lane runs on NVIDIA hardware, including a self-hosted Cloud Run fleet of L4 GPUs and an RTX PRO 6000 Blackwell.++**HackerNoon.** HackerNoon is the platform's publishing partner. Announcements auto-import from the three.ws RSS feed into the HackerNoon queue, with canonical links pointing back to three.ws.++**Quicknode.** three.ws was accepted into the Quicknode Startup Program in July 2026 with approved infrastructure credits, and Quicknode serves as one rung in the Solana RPC failover chain behind agent wallets, settlement verification, and live market data.++## Where three.ws is listed++Agents, servers, and apps from three.ws are live across a growing set of directories:++- **Official MCP Registry**, with 72 servers published under one namespace, including the hosted three.ws server, the 3D Studio servers, and the agent and avatar servers.+- **PulseMCP** and **LobeHub**, where three.ws MCP servers are discoverable as installable servers.+- **BNB Chain Dappbay**, listed under AI Agent Launchpad, AI Data, and AI Infra.+- **Alibaba Cloud International Marketplace**, with a product listing, a storefront, and the editorial feature mentioned above.+- **Solana dApp Store**, where the three.ws Android app for Seeker and Saga is live, with every wallet interaction routed to the phone's Seed Vault through Mobile Wallet Adapter.+- **Hugging Face**, with the three-ws organization, an Avatar Viewer Space, an avatars model repository, and published articles.+- **IBM Community blog**, with a post on three.ws and the 3D AI agent stack.+- **pump.fun**, where a feature article on the $THREE coin page profiles the platform's 3D agents, onchain identities, studios, and MCP server.++Coming next: the AWS Marketplace listing and the OpenAI Plugin Directory, where three.ws already meets the gating requirement of a public OAuth 2.1 MCP server.++## $THREE: the platform's coin++$THREE is the coin of three.ws, on Solana, at contract address `FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump`. It is a verified project on pump.fun, and the platform reads that verification live from pump.fun's public coin record rather than hardcoding it. On 2026-10-08, the public stats endpoint at `GET https://three.ws/api/three-token/stats` reported 4,356 registered agents on the platform, 15,170 $THREE holders, and a 10 percent revenue-share pool.++The token is woven into the product:++- **Hold to access.** Tiers from Bronze at $25 held to Genesis at $2,500 held unlock compute discounts of up to 30 percent and free-quota multipliers of up to 10x, resolved from the live value of tokens held, never spent.+- **Spend at a discount.** Pro, Team, and Enterprise plans and the Premium Data API pass are 20 percent cheaper in $THREE.+- **The marketplace currency.** Skills and assets in the marketplace are priced in $THREE, the agent labor market escrows rewards in $THREE, and bounties in Agora, the platform's shared agent and human world, escrow in $THREE by default.+- **x402 acceptance.** Paid endpoints can advertise $THREE alongside USDC on the same challenge.+- **One-signature allowances.** A holder can authorize a $THREE spending cap once through Solana's native allowances, keeping tokens in their own wallet.++The published economic policy commits **50 percent of platform revenue to market buybacks of $THREE**, routed to the treasury, and the platform never burns supply. The daily buyback lane and a micro-buy lane that turns settled x402 calls into small $THREE purchases are both built, capped, and reported publicly on the same stats endpoint, so anyone can follow them.++## Roadmap: what is live and what comes next++The roadmap in the repository is organized in phases, and every one of them already has working code.++**Phase 0, foundations: shipped.** The viewer, the agent runtime, ERC-8004 and Metaplex Core identity, the OAuth 2.1 server, the MCP endpoint, and the `<agent-3d>` web component are all live.++**Phase 1, selfie to avatar.** Capture, reconstruction, rigging, storage, and a draft mint (ERC-8004 on EVM, Metaplex Core on Solana) are wired end to end. Likeness fidelity, measured by a published shape-error metric, is the active track.++**Phase 2, personalization and voice.** Voice cloning, persona, and memory seeds have shipped behind the demos hub, with main-flow integration next.++**Phase 3, the onchain economy.** A bonding-curve simulator, an attestation-based reputation viewer, and revenue-split SDKs have landed. Per-call skill royalties are live on the x402 rail and accrue in the royalty ledger, the Reputation Staking Market is open on devnet, and the Solana skill-license program is built and tested. Agent token contracts and their audits come next.++**Phase 4, the open inference network.** The open node-operator client (CPU and CUDA builds) and a job queue at `/api/nodes` have shipped. Each node holds its own Solana ed25519 identity, runs real local inference, and returns results with signed receipts that the server recomputes, so anyone can verify a result offline. Independent operators serving production traffic is the goal this phase is building toward.++**Phase 5, native widgets.** The glance card endpoint (JSON, SVG, PNG, and Adaptive Card), a Windows 11 widget, an `<agent-glance>` element, and an Android home-screen widget have shipped, with macOS and iOS next.++Nearer term, the onchain to-do list is concrete and upbeat: the ValidationRegistry on EVM mainnets, deployment of the three Anchor programs from their reserved program ids, mainnet enablement for the Reputation Staking Market, and the AWS Marketplace and OpenAI Plugin Directory listings.++## The bottom line-That makes an agent a *first-class citizen of the open internet*, not a tenant on someone's server.+AI agents are becoming one of the main kinds of software people interact with. That raises simple questions with deep answers: where does an agent live, who owns it, how does it get paid, and how can anyone confirm that the agent they are talking to today is the same one they trusted yesterday?-The infrastructure for that vision is shipping today, on Ethereum and Base and Polygon and Arbitrum and Optimism and Linea and Scroll and Avalanche and Celo and BSC and Gnosis and Fantom and zkSync and Moonbeam and Mantle and Solana. The roadmap from there to a full onchain agent economy, tokens, royalties, reputation markets, decentralized inference, is published, scoped, and open for partners.+three.ws answers with open, crypto-native infrastructure. An agent's identity is an asset its owner holds, as a Metaplex Core asset in the three.ws Agents collection on Solana or an ERC-8004 token at the same `0x8004` address across a dozen EVM mainnets. Its configuration is pinned to IPFS. Its reputation and validations are public attestations. Its wallet runs under a policy its owner controls, and it earns and spends over x402 on a settlement rail three.ws operates itself.-If you've been waiting for the moment AI and crypto stop talking past each other, this is what it looks like when they don't: an agent with a body you can see, a brain you can talk to, an identity nobody can take away, and a wallet of its own.+On top of that infrastructure sits a product people can enjoy right away: a character with a body you can see, a voice you can hear, a brain you can talk to, an identity you own, and a wallet of its own, ready to live on a website, inside an AI assistant, or at a real place on the map.----*three.ws is open source under Apache-2.0. The repo, contracts, and full roadmap are at [github.com/nirholas/three.ws](https://github.com/nirholas/three.ws). The platform is live at [three.ws](https://three.ws).*+*three.ws is open source under Apache-2.0. The code, contracts, specs, and full roadmap are at [github.com/nirholas/three.ws](https://github.com/nirholas/three.ws). The platform is live at [three.ws](https://three.ws). $THREE contract address: FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump.*diff --git a/docs/coinmarketcap-live-article.md b/docs/coinmarketcap-live-article.mdindex a5620322d..f10f2b3d1 100644--- a/docs/coinmarketcap-live-article.md+++ b/docs/coinmarketcap-live-article.md@@ -1,114 +1,760 @@----title: "Live Now: Inside IBM's First In-World Community Meetup on three.ws"+title: "Live Now: Inside the Three.ws User Group on IBM Community's First In-World Meetup"target: CoinMarketCap Community / Editorialstatus: draft, fill bracketed fields from the live event before publishing----# Live Now: Inside IBM's First In-World Community Meetup on three.ws+# Live Now: Inside the Three.ws User Group on IBM Community's First In-World Meetup-_This is a live dispatch, not a recap. Fill every bracketed field from what is actually happening-in-world before publishing; do not guess at numbers. Publish once there is real texture to report,-not at the 8 AM open. A recap version goes up after 5 PM PT once the day is over._+_This is a live dispatch, written while the doors are open. Fill every bracketed field from what is+happening in-world before publishing, using only numbers and moments observed today. Publish once+the day has real texture to report, a little after the 8 AM open. A recap version follows after+5 PM PT once the day wraps._-## What's happening right now+## Pull up a chair (or rather, walk up to one)++If you have never stepped into a 3D world from a browser tab, today is a lovely day to start.Right now, on [three.ws/play](https://three.ws/play), the Three.ws User Group on IBM Community is-holding its first in-world meetup: not a webinar, not a call, an actual persistent 3D world that-anyone can walk into from a browser tab. **Friday, August 7, 2026, 8 AM to 5 PM Pacific**, in the-$THREE home town, the flagship world pinned at the top of the /play lobby.--The number climbed all day and peaked at **3,145 avatars in the plaza at once**. The in-world-jumbotron over the plaza showed the running headcount to anyone who walked up to it, which was-itself part of the point: a community meetup you could watch fill up in real time, from inside the-room.--## Why this one is worth watching--Plenty of crypto projects claim an enterprise partnership. Very few can point to a dedicated user-group on that enterprise's own community platform, and three.ws is, as of today, the only project-with a standing [group of its own on IBM Community](https://community.ibm.com/community/user/usergroup?CommunityKey=e71510cc-d953-408f-9a1c-019f5c0a7016).-That group didn't happen because of a slide deck: three.ws's public X exchanges with IBM-([@trythreews](https://x.com/trythreews) and [@IBM](https://x.com/IBM) itself, see+holding its first in-world meetup. Picture a town square that anyone can walk into: a plaza with a+giant slowly turning gold coin at its center, a stadium-sized screen towering over it, streets and+storefronts around the edges, fishing ponds a short stroll away, and hundreds of people moving+around as 3D avatars, chatting, exploring, and getting to know each other. That town is the $THREE+home town, the flagship world pinned at the top of the /play lobby, and today it is the venue for a+real community meetup.++The program opened at **8 AM Pacific on Friday, August 7, 2026**, and the gathering carries on+through **5 PM Pacific**. Over the course of the day the crowd peaked at **3,145 avatars in the+world at once**. The jumbotron over the plaza shows the running headcount of the community to anyone+who walks up to it, so the meetup has the rare quality of letting you watch it fill up in real time,+from inside the room.++Anyone can enjoy what is happening, whatever their background in 3D, AI, or crypto. You open a+link, you pick an avatar, and you are standing in the plaza with everyone else. If someone nearby is+talking, you hear them. If you walk toward a group, their conversation gets louder. If you wander off+toward the fishing ponds, the plaza chatter fades behind you, just like it would in a real park.++The rest of this dispatch starts with the friendly basics (what three.ws is, how to get in, and what+you can do once you are there), then goes deeper: the history of the user group, the IBM+integration, the partner programmes behind the platform, and the multiplayer architecture that+holds a crowd this size together.++## What three.ws is, in plain language++[three.ws](https://three.ws) is a platform for 3D AI agents that runs entirely in your web browser.++That phrase packs in a few ideas, so here they are one at a time.++**A 3D avatar.** On three.ws you can make a 3D character from a sentence of text, from a photo of+yourself, from scratch in an avatar editor, or from a model file you already have. The platform+rigs it automatically, which means it gets a skeleton so it can walk, wave, sit, and dance. The+rigging works with avatars from many different tools: the platform reads whatever skeleton a file+arrives with (Mixamo, VRM, Daz, Blender conventions and more) and maps it onto a shared set of+bones, so the same animations play on all of them.++**An AI agent.** That avatar can also have a brain: an AI model it thinks with, a personality, a+memory, and skills. You can talk to it, embed it on a website with a single HTML tag+(`<agent-3d>`), and give it tools so it can take actions on your behalf.++**An on-chain identity and wallet.** Every agent can carry its own Solana wallet and a verifiable+on-chain identity, so it can pay for services and get paid for its work. Payments between agents+and paid APIs run over x402, an open protocol for paying per request over HTTP.++**Free creation tools.** The [Forge](https://three.ws/forge) turns a typed description, a photo, or a+sketch into a downloadable, textured 3D model. The [create hub](https://three.ws/create) is the front+door for making avatars, agents, models, and token worlds.++**Worlds you can walk into.** [/play](https://three.ws/play) turns every coin launched on pump.fun+into a live multiplayer 3D world, with the $THREE home town as the flagship. That is where today's+meetup is happening.++**Open source.** The whole platform is open source under the Apache-2.0 licence at+[github.com/nirholas/three.ws](https://github.com/nirholas/three.ws), so anyone can read how every+piece works.++$THREE is the platform's own coin (contract address `FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump`+on Solana). It prices premium cosmetics in the /play boutique, and its home town is the world you+are reading about.++## Getting in: under a minute, from any browser++Joining is designed to be as easy as opening a video:++1. **Open [three.ws/play](https://three.ws/play)** in any modern browser, on a laptop or a phone.+2. **Click the pinned $THREE world** at the top of the lobby. It carries an official badge and sits+ above the trending coins.+3. **Pick an avatar.** Guests get one automatically, so you can walk straight in. If you want to+ arrive as yourself, build a custom avatar first at [three.ws/create](https://three.ws/create)+ from a text prompt or a selfie, and it follows you into the world. You can also choose a preset,+ browse the public gallery, paste a model URL, or drop in your own `.glb` file.+4. **Walk up to people and say hello.** Move with WASD and the mouse on desktop, or the on-screen+ joystick on mobile. Tap the mic to talk with spatial voice, or use text chat with floating+ speech bubbles.++Everything runs in the tab: nothing to install, and watching or joining the meetup needs no account+and no wallet. The three.ws team welcomes first-timers at the spawn point, and the announcement post+encouraged newcomers to arrive ten minutes early so they would be walking and talking by the time+the program began.++A few keys worth knowing once you are inside: **C** cycles the camera between Follow, Cinematic,+First Person, and Top Down; **M** shows or hides the rotating radar in the corner (click it to walk+your avatar to that spot); **J** opens the friends drawer, where friends see you online and can send+you direct messages while you play; **F** gets you in and out of a car; and **H** opens the controls+panel, including a Power saver switch.++## Why today is a milestone worth celebrating++The Three.ws User Group on IBM Community is a dedicated+[group of its own on IBM Community](https://community.ibm.com/community/user/usergroup?CommunityKey=e71510cc-d953-408f-9a1c-019f5c0a7016),+and its organizer on IBM's side has described three.ws as the only project she knows of with a user+group like it. The group grew out of genuine public enthusiasm: three.ws's public X exchanges with+IBM ([@trythreews](https://x.com/trythreews) and [@IBM](https://x.com/IBM) itself, see[here](https://x.com/IBM/status/2061418285896269952) and-[here](https://x.com/IBM/status/2061488909264040194)) went viral more than once, enough that-people inside IBM who have nothing to do with the partnership know the project by name. A meetup-that runs 8 AM to 5 PM, held inside the product instead of on a call, is what that attention turned-into.--The format says something about both sides. IBM is the definition of enterprise software, and-three.ws is a browser-native 3D platform built on generative AI and a Solana token. Neither side-treated that as a mismatch, and the partnership itself is a matter of public record: three.ws is-an [IBM Business Partner](https://three.ws/ibm/hello), covered by outside press including+[here](https://x.com/IBM/status/2061488909264040194)) drew wide attention and helped put the+project on the radar of people across IBM. Today's meetup, a full day held inside the product+itself, is where that energy has led.++The format is a natural fit for both sides. IBM brings decades of enterprise AI and a community of+developers, data scientists, and architects. three.ws brings a browser-native 3D platform built on+generative AI, with Solana at its core. Both share an appetite for trying things that are genuinely+new, and a user-group meetup you attend as an avatar is exactly that.++The partnership itself is a matter of public record: three.ws is an+[IBM Business Partner](https://three.ws/ibm/hello), covered by outside press including[Business Insider](https://markets.businessinsider.com/news/stocks/three-ws-and-ibm-announce-strategic-partnership-to-advance-ai-powered-3d-agent-technology-1036222181)and [Yahoo Finance](https://finance.yahoo.com/sectors/technology/articles/ibm-extends-ai-narrative-three-010650764.html).-The user group's own organizer, Jessica Swanson of the IBM Community team, described the format-plainly in her [announcement blog](https://community.ibm.com/community/user/blogs/jessica-swanson/2026/08/04/join-the-threews-user-groups-first-in-world-meetup):++Jessica Swanson, who organizes the group on IBM's side, described the format beautifully in her+[announcement blog](https://community.ibm.com/community/user/blogs/jessica-swanson/2026/08/04/join-the-threews-user-groups-first-in-world-meetup):"It is not a video call. You attend as an avatar, you hear the people standing near you through-spatial voice chat, and the product tour happens by literally walking through the product." That's-the whole pitch, and today is the day it's being tested in front of a real crowd instead of a press-release.--## What the room actually looks like--A meetup inside a persistent multiplayer world doesn't read like a meetup; it reads like a place.-Over the course of the day, attendees have been doing what people actually do when you put them in a-3D world together rather than a Zoom grid: walking up to strangers and talking (voice is spatial, so-a conversation twenty meters away doesn't bleed into yours), fishing and cooking at the world's-crafting stations, driving vehicles around the map, and building on the shared voxel layer in the-plaza. [Swap in the specific moments that actually happened today, e.g. a named demo, a group photo,-a particular build, once they're known. Keep this section concrete and first-hand, not generic-"attendees enjoyed themselves" language.]--None of that is scripted content. It's the same in-game economy and building layer every /play-world runs on: vendor NPCs, banking, quests, vehicles, and persistent collaborative building, being-used, today, by people who came for a corporate user group meetup and stayed because the venue-turned out to be a real place.--## The technical program, alongside the vibe--Underneath the fishing and the driving, the actual agenda is running: a live tour of the platform-from inside the world, community demos (attendees bring what they've built on three.ws: avatars,-embeds, MCP integrations, agents), and open Q&A with the three.ws team, including questions about the-two IBM-native pieces of the stack: [`@three-ws/ibm-watsonx-mcp`](https://www.npmjs.com/package/@three-ws/ibm-watsonx-mcp)-(watsonx.ai on your own IBM Cloud account) and [`@three-ws/ibm-x402-mcp`](https://www.npmjs.com/package/@three-ws/ibm-x402-mcp)-(pay-per-use IBM Granite billed in USDC, no IBM account required), both open-source and installable-today. There's also a live browser demo of the x402 side at [three.ws/ibm/x402-demo](https://three.ws/ibm/x402-demo).+spatial voice chat, and the product tour happens by literally walking through the product." That is+the whole pitch, and today it is playing out in front of a real crowd.++## A short history of the Three.ws User Group++The meetup is the latest chapter in a summer of steady collaboration on IBM Community.++### June: the first live build, in IBM's Global AI and Data Science community++On June 23, 2026, three.ws ran **Building 3D AI Agents Live: From Prompt to Embeddable Agent in+Minutes**, a one-hour live-build session in IBM's+[Global AI & Data Science](https://community.ibm.com/community/user/events/event-description?CalendarEventKey=2767712c-6efd-47dc-aaeb-019ec4126e27&CommunityKey=f1c2cf2b-28bf-4b68-8570-b239473dcbbc)+community, featuring a special guest from IBM. The engineering team built and shipped a 3D,+interactive, fully embeddable AI agent from a single text prompt, live: generating the agent,+embedding it into a site as simply as a video, and wiring it to real tools and data. Earlier that+month, IBM Community had already published+[The Open On-Chain Platform for 3D Agents](https://community.ibm.com/community/user/blogs/jessica-swanson/2026/06/11/threews-the-open-on-chain-platform-for-3d-agents),+introducing three.ws to its readers as an open-source platform for persistent, ownable AI agents.++### July 14: the welcome post and the group charter++The group launched in July with+[Welcome to the Three.ws User Group: Building AI Agents With 3D Capabilities](https://community.ibm.com/community/user/blogs/jessica-swanson/2026/07/14/welcome-to-the-threews-user-group-building-ai-agen).+That post set out four focus areas that still define the group today:++- **Generative 3D:** turning text and images into production-ready meshes.+- **Spatial reasoning:** how language models understand 3D environments.+- **Agentic pipelines:** multi-step workflows where AI generates and refines assets on its own.+- **Real-time interactive AI:** animated characters and responsive AR in the browser.++It welcomed ML engineers, web and game developers, 3D artists, agent-framework builders, and+product developers, and promised discussion threads, technical blogs, live build sessions, and a+resource library. Over the following weeks, the group filled with hands-on material: a full+platform tour, a step-by-step guide from a text prompt to an embeddable 3D agent, a hands-on+walkthrough of the Forge, a troubleshooting guide for GLB files that render flat, and a roundup of+ten platform features.++### August 4: the meetup announcement++On August 4, Jessica published+[Join the Three.ws User Group's First In-World Meetup This Friday](https://community.ibm.com/community/user/blogs/jessica-swanson/2026/08/04/join-the-threews-user-groups-first-in-world-meetup),+alongside a pinned discussion thread from the three.ws team,+[Community Meetup Inside three.ws: Join Us on the $THREE Server at three.ws/play](https://community.ibm.com/community/user/discussion/community-meetup-inside-threews-join-us-on-the-three-server-at-threewsplay),+which carries the long technical write-up behind the event. Her framing was simple and generous:+the venue is the demo. An hour at the meetup doubles as an hour of hands-on evaluation of the+technology the group exists to discuss, and because every world is a shareable URL, what attendees+learn applies directly to running events of their own.++The agenda she announced is the one running today: a live tour of the platform from inside it,+community demos from members who bring what they have built, open Q&A with the three.ws team, and a+first look at what is coming next on the platform.++## What the room looks like++A meetup inside a persistent multiplayer world reads less like a meeting and more like a place.+Over the course of the day, attendees have been doing what people naturally do when you put them in+a 3D world together: walking up to new faces and talking (voice is spatial, so a conversation twenty+meters away stays in its own corner of the plaza), fishing at the ponds and cooking the catch,+driving cars around the district, and building together on the shared voxel layer in the plaza.++Jessica herself has spent part of the day doing exactly that: fishing, cooking what she caught, and+driving around the map with other players, which captures the spirit of the format perfectly.++[Swap in the specific moments from today: a named demo, a group photo, a particular build, a+memorable exchange in the Q&A. Keep this section concrete and first-hand, drawn from what attendees+actually did.]++Everything people are enjoying here is the same living game and building layer every /play world+runs on: vendors, banking, quests, vehicles, and persistent collaborative building, being used today+by people who came for a user-group meetup and found a real place to spend the day together.++## Everything you can do in /play++If today is your first visit, here is a tour of what is waiting for you. Every feature below is live+in /play and documented in the platform's public changelog.++### Every coin is a world++The core idea behind /play is simple: every coin is a room, keyed to its contract address. Open the+lobby and you see trending coins, plus a search box that reaches any coin launched on pump.fun. Pick+one and you drop into a world built just for it.++Each world is generated deterministically from the coin's address. The address becomes a seed, the+seed picks one of several biomes (Verdant Meadow, Dune Sea, Frostfields, Ashen Caldera, Neon+Expanse, Lagoon Shore), and the same seed tunes the palette and scatters the flora. A given coin+always renders the same world, so its place is truly its own, and a thousand coins render a thousand+recognizably different worlds. Every world is also a plain shareable link, so a community can send+someone straight into its plaza.++### The $THREE home town++One world sits pinned at the top of the lobby with an official badge and a fixed signature biome:+the $THREE home town, three.ws's own community. Its name, art, and market cap refresh live, and it is+the world a first-time visitor lands in. It is also where live events like today's run, because the+event layer (countdown, agenda, fireworks, and souvenirs) is built into the home town.++### A real in-world economy: store, bank, and boutique++The open world has a working cash economy. Walk up to a **General Store** clerk to buy tools and+consumables or sell what you have gathered. Visit the **Bank Teller** to deposit cash into a+protected account: banked cash is safe through a knockout, while carried cash is yours to risk.+Trading and banking are walk-up actions the server enforces, which makes a trip to the bank before+an adventure a real decision.++Fashion has a physical home too. **Roux the Tailor** sells fits, hats, and paint jobs, and **Nell's+Fitting Room** lets you equip anything you already own. Premium wardrobe items in the boutique are+priced in $THREE and unlock with one on-chain payment from your connected Solana wallet, split+between the holder-rewards pool and the treasury, and the server grants the item only after+re-verifying the confirmed transaction on-chain. Your wardrobe carries across every coin's world,+wherever you bought it.++Every price, prize, and gate in this economy is published at+[three.ws/play/economy](https://three.ws/play/economy). The page reads the same tables the game+server prices trades with, so the number you see there is exactly the number you will be charged,+and it stays current automatically when the game is retuned.++### Jobs, quests, and the meetup's own leaderboard++Quest-giver NPCs, marked with a visible indicator, hand out missions from the **Jobs Board**, and+the server tracks and validates every one in real time. Driving jobs like Cross-Town Delivery and+East-West Express send you to grab a car at one of the four avenue depots and run a rush order to+the other side of town, and the delivery counts only when you actually drive it.++For the length of today's live event, the board carries four special jobs that exist only while the+doors are open: land a haul of fish for the plaza pit, drive the party supplies across town, clear+four foes out of the Southern Wilds, and tour the three meetup landmarks. They pay better than the+everyday board, they are repeatable, and an **Event** tab ranks the top ten players by jobs+finished, tiebroken by the cash those jobs paid, with your own rank pinned at the bottom. Winners+are announced from that board and settled by the team afterwards.++### Fishing, cooking, and gathering++Two fishing ponds with animated water (real ripples, a sun-tracked sparkle, and a deep-to-shallow+gradient that follows the day/night lighting) sit within a short walk of the plaza. Everyone starts+with a rod, and three spare rods lean on posts around the map for anyone to pick up. Trees, rocks,+and roast pits make up the chop, mine, and cook stations, and caught fish sell for cash at the+General Store. A skills panel shows the XP left to each next level and what the next unlock is.++### Vehicles and a drivable district++Downtown is ringed by a full street grid of asphalt avenues, sidewalks, lit buildings, and+streetlights, rendered identically for everyone in the world. Walk up to a parked coupe, sedan,+pickup, or buggy, press F (or tap it on mobile), and drive with WASD or on-screen pedals. Cars run+on full Rapier physics, with real suspension and steering, collisions with buildings, and an+auto-right after a flip. Every car is a shared world object: other players see you driving in real+time, the server makes sure only one person drives a given car at a time, and when you step out the+car stays parked exactly where you left it.++A wall-clock-driven day and night cycle sweeps the sun, sky, fog, window glow, and streetlamps in+sync for everyone, with the timing derived from the shared clock rather than sent over the network.++### Voxel building, and forging items right in the world++/play includes **collaborative voxel building**: a block palette and a build mode where people place+and break blocks together on a shared grid in the plaza. Every block is validated by the server and+synced to everyone in the room, and builds persist per coin, so a community's creation is still+standing when you come back tomorrow.++Building goes beyond blocks, too. Open build mode, click **Forge** in the props palette, and describe+an item ("a mossy stone lantern with a copper roof"), or attach a reference photo. About half a+minute later the finished 3D model is added to your props, ready to place. A chat shortcut does the+same: type `/forge a brass telescope` and the item lands ready to drop. Anything you place appears+for everyone connected to that server and stays there, exactly like a hand-built block. It is free+and needs no account or wallet.++### Spatial voice, chat, and friends++Voice in /play works the way your ears do. Walk up to someone and you hear them; drift away and they+fade out. Their voice comes from their direction, so someone on your left sounds like they are on+your left. The audio is peer-to-peer WebRTC with HRTF spatial panning and distance falloff, and+connections open only to the people near enough to hear, which keeps the voice layer light however+busy the plaza gets. Voice is opt-in (your mic stays off until you tap it), and a speaker's nameplate+pulses while they talk, so you can pick them out of a crowd. Text chat with floating bubbles and a+set of emotes complete the picture.++### The holders' world++Every coin has two connected worlds. The **open world** is the front door: anyone can walk in, look+around, and watch the market move the sky. The **holders' world** is the community's own room,+open to wallets holding at least $8 worth of that coin. Inside, everyone you meet shares a stake in+the same coin, which turns the holders' world into a gathering of people with a common interest+rather than a list of followers.++### The world reacts to the market, live++Every /play world streams its coin's real on-chain trades and turns them into the environment:++- **Every buy ripples green** across the plaza and kicks the glowing boundary ring, and every sell+ ripples red.+- **Sustained volume spins the coin totem faster,** so the room visibly speeds up when trading heats+ up.+- **The rolling percentage change becomes the weather:** green opens the fog and flares the sun, red+ draws the fog in and dims the light. The mood drifts like a tide, so it reads as atmosphere.+- **A whale trade lands like a celebration:** a column of light fires above the totem, a shockwave+ rolls across the plaza, and on a big buy a fountain of golden coins rains from the top.++### A trading terminal you can walk up to++Past the totem stands a second giant screen: a live in-world **trading terminal** for the coin. It+shows the price (with the sub-decimal notation small-cap coins need), a live session chart, market+cap, live volume, trade count, buy and sell flow as a pressure bar, and a scrolling ticker of the+latest real trades. A native in-world buy flow lets you act on what you see: the server builds the+transaction, your own Solana wallet signs it, and it broadcasts, all while you stand in the plaza.++In the $THREE home town there is also an **Intel Kiosk** by the plaza. Walk up, press E, and buy live+$THREE market intel (price, 24-hour change, market cap, and a signal) for $0.01, paid from your own+wallet over x402 and settled on-chain on Solana. The same oracle is listed for agents to buy, which+makes the kiosk a small, tangible demonstration of agent payments in action.++### Just for fun++Plenty of what makes the world feel alive is pure play:++- **Tag:** with two or more players in a room, someone becomes "it", and tags transfer on proximity+ that the server validates from authoritative positions.+- **A dance floor** near the totem: step on, press Dance, and everyone armed on the floor switches+ to the same dance at the same beat, every four seconds, under pulsing lights.+- **A kickable beach ball** in every world.+- **Fortune's Folly,** a Wheel of Fortune in the Mainland plaza: one free spin every 12 hours, or a+ paid spin for $3 in $THREE, split evenly between the holder-rewards pool and the treasury and+ verified on-chain before any prize is granted. Its full paytable, with the real chance of each+ outcome, is published on the economy page.+- **Combat** with swords, monsters, and a wanted meter, for anyone who wants an adventure out in the+ wilds.++### Event dressing: countdown, fireworks, and the Meetup Laurel++Live events in the home town come with their own stagecraft, all driven by a single schedule file.+A countdown sits at the top of the screen from a day out and turns into a LIVE marker at the start;+tap it for the full running order, including what is on right now and what is next. Banners announce+each segment, and a synchronized fireworks show kicked off the day for everyone watching together,+timed from the shared clock so it stays in sync for every viewer however large the crowd.++Everyone who walks into the event world while it is live receives the **Meetup Laurel**, a gold+laurel circlet with three pearl berries at the front. A card slides in at the corner of the screen+with a button to put it on right away, and if you dismiss it the laurel waits in My Fits. It is free,+it is yours permanently, it wears in every coin world, and the server decides you earned it. It is+granted only while the event is live, so the laurel is a lasting keepsake that says you were there.++## The technical program, alongside the fun++Underneath the fishing and the driving, the formal agenda is running: a live tour of the platform+from inside the world, community demos (attendees bring what they have built on three.ws: avatars,+embeds, MCP integrations, agents), and open Q&A with the three.ws team.++The Q&A naturally reaches across the whole platform. The Forge comes up often: free text-to-3D,+where a typed sentence becomes a textured model. So does the Avatar Studio, which rigs what it+generates so a creation can walk and sit like everyone else in the world, and the universal+retargeting that lets avatars from entirely different pipelines move the same way the moment they+load. The shared wardrobe layer and the `<agent-3d>` web component, which lets any website embed one+of these avatars and drive its animation and mood from its own code, round out the tour.++A good share of the questions focus on the two IBM-native pieces of the stack:+[`@three-ws/ibm-watsonx-mcp`](https://www.npmjs.com/package/@three-ws/ibm-watsonx-mcp) (watsonx.ai+on your own IBM Cloud account) and+[`@three-ws/ibm-x402-mcp`](https://www.npmjs.com/package/@three-ws/ibm-x402-mcp) (pay-per-call IBM+Granite settled in stablecoin, with no IBM account required), both open source and installable today.+There is also a live browser demo of the x402 side at+[three.ws/ibm/x402-demo](https://three.ws/ibm/x402-demo).+[Note any specific demo or Q&A moment worth naming once it happens.]-## Why a meetup format is a CMC-relevant data point, not just a nice story+The next section goes deep on both connectors, for readers who want the detail.++## The IBM integration in depth++three.ws is an IBM Business Partner, and its IBM work spans three layers: a hosted platform+integration with IBM watsonx.ai, a set of Granite-powered API surfaces, and two open-source MCP+connectors. The public `/api/ibm` Granite tools are independent developer tools three.ws built on+IBM's publicly available Granite models, offered as an open playground for developers to explore+Granite and build their own integrations.++### watsonx.ai on your own IBM Cloud account++three.ws agents can think on **IBM Granite** foundation models served through **IBM watsonx.ai**,+using your own IBM Cloud credentials. One IBM Cloud API key plus a watsonx.ai project (or deployment+space) unlocks the whole suite.++The wiring follows the watsonx.ai REST contract closely:++1. **IAM token exchange.** An IBM Cloud API key is exchanged at IBM's IAM endpoint for a short-lived+ bearer token, cached and refreshed five minutes before expiry, so a warm instance pays the+ exchange once rather than per request. Concurrent callers share a single in-flight exchange.+2. **Project scoping.** Every inference carries the watsonx.ai project or space it runs in.+3. **Version stamping.** Each call is version-stamped, with the chat, embedding, and vision+ endpoints on one API version and the Time Series Forecasting API on its own.+4. **Clear, real errors.** Any authentication, quota, or region issue surfaces with its true status+ and message, so a developer always knows exactly what to adjust.+5. **A deadline on every call.** The IAM exchange gets a short deadline with retries, and each+ inference gets a single attempt with a generous deadline, so every request resolves promptly.++The streaming chat endpoint returns an OpenAI-shaped stream, which lets the avatar runtime reuse its+existing reader unchanged. The default host is `us-south`, and the other watsonx.ai regions+(`eu-de`, `eu-gb`, `jp-tok`, `au-syd`, `ca-tor`) are one setting away.++### The Granite models in use++- **Chat and narration:** `ibm/granite-3-8b-instruct`.+- **Embeddings:** `ibm/granite-embedding-278m-multilingual`.+- **Time-series forecasting:** the Granite TinyTimeMixer family (`granite-ttm-512-96-r2`,+ `-1024-96-r2`, `-1536-96-r2`), with the platform picking the largest model the available history+ can fill.+- **Vision:** `ibm/granite-vision-3-2-2b`.+- **Governance:** `ibm/granite-guardian-3-8b`.++### The Granite surfaces++Each of these is a live API surface documented in the three.ws docs:++- **Granite as the avatar brain.** Any three.ws agent can select watsonx Granite as its brain,+ alongside the other providers. A Granite-brained avatar speaks, emotes, and uses skills exactly+ like any other agent.+- **The Trust Layer, with Granite Guardian.** Guardian sits between an agent's reasoning and its+ actions, classifying a message or a proposed action across named risks (jailbreak, harm, social+ bias, violence, profanity, and more) and collapsing the verdicts into a single allow, review, or+ block decision. It runs inline before an avatar sends value, and a block verdict stops the action.+ Every verdict is written to a hash-chained audit ledger that anyone can re-verify with SHA-256, and+ autonomous sends also respect a per-period spending cap.+- **Granite Oracle.** Forecasts a live Solana token's price with Granite TimeSeries over real+ historical candles, narrates the forecast with Granite chat, and runs that narration through+ Guardian before returning it.+- **Granite Proof.** Takes a governed forecast, hashes the claim, and notarizes it on Solana as a+ compact memo transaction that names the models used and the governance result. Statements that+ pass Guardian are the ones that get signed, which makes every proof an auditable, governed claim+ on a public ledger.+- **Digital Twin.** Mirrors a live token's vitals (momentum, volatility, activity, liquidity, and a+ "heartbeat") and projects its near future. It back-tests itself against what actually happened,+ reporting accuracy openly, and runs what-if scenarios by perturbing the recent window and+ re-forecasting.+- **Agent Galaxy.** Embeds every public agent with Granite embeddings, projects the vectors into 3D,+ clusters them, and asks Granite to name each cluster, producing a star map where similar agents+ sit near each other. A natural-language search finds agents by meaning.+- **watsonx Constellation.** A live page at [three.ws/constellation](https://three.ws/constellation)+ that applies the same embedding space to trending Solana tokens, renders each as a star, and+ streams a Granite analysis of any star you pick. It always names the model that actually served+ each answer.+- **Identity Firewall.** Before a new agent identity is created, its name and description are+ embedded and compared against existing public agents to catch impersonation, and Guardian screens+ the text, protecting the reputation every trusted agent has earned.+- **Granite Vision.** Show it a rendered avatar and it returns a complete agent identity:+ appearance, vibe, persona, a suggested name, a one-line bio, tone tags, and a fitting voice, in a+ single multimodal call.+- **Standalone embeddings.** A public endpoint exposes Granite embedding vectors for your own+ semantic search or clustering, and reports the model that served each batch.++The integration ships with executable verification scripts and unit tests in the open-source repo.++### `@three-ws/ibm-watsonx-mcp`: watsonx.ai in any MCP client++This is a standalone [Model Context Protocol](https://modelcontextprotocol.io) server that brings+watsonx.ai to any MCP host, such as Claude Desktop, Claude Code, or Cursor, using your own IBM Cloud+credentials. It speaks directly to the watsonx.ai REST API, with no intermediary backend and no+telemetry. Five tools:++- `watsonx_chat`: chat completion from role and 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 counts against a model's tokenizer.+- `watsonx_list_models`: the foundation models available to your account and region.++Starting it takes one line:++```bash+WATSONX_API_KEY=... WATSONX_PROJECT_ID=... npx @three-ws/ibm-watsonx-mcp+```++### `@three-ws/ibm-x402-mcp`: pay-per-call Granite for agents++The second connector solves a different problem. An autonomous agent wants Granite on demand, mid+task, and the simplest way to give it that is a metered utility it can pay for from a wallet it+already controls. In this suite, the operator holds the IBM credentials and funds inference, and the+caller pays a few cents in stablecoin per call over [x402](https://x402.org). Granite becomes+something any agent can consume the moment it has a funded wallet.++It offers one free tool and five paid ones:++- `ibm_granite_getting_started` (free): an overview of the suite, per-tool prices, and how the x402+ payment flow works. The ideal first call for a new client.+- `ibm_granite_chat` ($0.02): conversational AI for Q&A, drafting, reasoning, and instruction+ following, on Granite 3 8B Instruct.+- `ibm_granite_code` ($0.025): generate, review, refactor, explain, test, or document code.+- `ibm_granite_embed` ($0.005): batch text embeddings for retrieval, search, and clustering.+- `ibm_granite_analyze` ($0.04): structured document analysis covering entities, sentiment, risk+ flags, a summary, and next steps.+- `ibm_granite_forecast` ($0.05): zero-shot time-series forecasting with Granite TTM, with no+ training step.++The Granite 3 tools also work in German, Spanish, French, Portuguese, Japanese, Korean, Italian,+Dutch, Chinese, Arabic, and Czech.++The same tools ship over two transports. The npm package runs locally over stdio+(`npx @three-ws/ibm-x402-mcp`) for hosts like Claude Desktop, Claude Code, and Cursor, with per-call+payment on Solana. The hosted endpoint at `https://three.ws/api/ibm-mcp` serves hosted clients,+watsonx Orchestrate, and custom agents over Streamable HTTP, with payment on Solana or Base.+Authenticated three.ws accounts, including a watsonx Orchestrate connection with a Bearer+credential, can call the hosted tools as part of their connection.++A paid call is one smooth loop:++1. The client calls a tool, and the server answers with an HTTP 402 quoting the exact price and the+ receiving address.+2. The client signs a stablecoin transfer.+3. The client retries with the signed payment attached.+4. The server verifies the payment through an x402 facilitator, calls watsonx.ai, and settles.+5. The response carries the result plus a settlement receipt.++x402-capable clients run that whole loop automatically, so to the agent it feels like a single tool+call that costs a few cents. Both transports are registered in the official MCP Registry.++### The live IBM pages: `/ibm/hello` and `/ibm/x402-demo`++[three.ws/ibm/hello](https://three.ws/ibm/hello) is the IBM and three.ws partnership page. It+explains how three.ws's agent identity, x402 payment rails, and MCP servers integrate with IBM+watsonx.++[three.ws/ibm/x402-demo](https://three.ws/ibm/x402-demo) is a self-contained x402 micropayment demo.+Pay a tenth of a cent in stablecoin from your own wallet (Phantom on Solana, or MetaMask on Base) to+call a real three.ws data API, and watch every step: the live HTTP 402 challenge, a gasless signed+authorization, and the on-chain settlement receipt. It needs no account and no backend of your own,+which makes it one of the quickest ways to see agent payments working end to end.++## The partner ecosystem behind the day++Today's meetup is an IBM Community event, and the platform hosting it draws on a wider set of+programmes. Each one shows up somewhere in the experience attendees are having right now: the+servers holding the crowd, the GPUs generating avatars, the RPC endpoints reading the chain, and the+channels carrying the story outward. The public map is [three.ws/partners](https://three.ws/partners),+where each card carries a one-word category chip. These are programme memberships and designations,+and each partner's own wording is used below.++### IBM: IBM Business Partner++IBM carries the "Strategic" chip on the /partners page. three.ws is an IBM Business Partner, its+agent runtime runs on IBM watsonx.ai with your own IBM Cloud credentials, and the integration covers+watsonx.ai, Granite, x402, and MCP, as described above. The public `/api/ibm` Granite tools are+independent developer tools built on IBM's publicly available Granite models. And, of course, IBM+Community is home to the user group holding today's meetup.++### OpenAI: Select Partner in the OpenAI Partner Network++three.ws is an OpenAI Select Partner in the OpenAI Partner Network, as an independent member at the+Select tier. The free, keyless three.ws 3D Studio connector gives ChatGPT eleven 3D tools, including+text to model, rigged avatars, conversational refinement, model inspection, and a living agent body,+rendered interactively inside the conversation. A custom GPT, one-tap AR handoff, and Spatial MCP+(an open, CC0 response shape that makes a 3D scene a native MCP result, with three.ws as the+reference implementation) complete that surface. Models made there are standard GLB files, the same+format the /play avatar picker welcomes.++### Google Cloud: member of Google Cloud for Web3 Startups++three.ws is a member of Google Cloud for Web3 Startups, with the programme backing compute and+Vertex AI usage. Production runs on Google Cloud: a Cloud Run service serves the frontend and every+API handler, scheduled jobs run on Cloud Scheduler, and the GPU model workers run as their own+services. Most relevant today, the multiplayer server that hosts the $THREE home town runs as its+own Cloud Run service, so every avatar in the plaza right now is connected to Google Cloud. Vertex+AI provides the Gemini and image lanes.++### NVIDIA: member of NVIDIA Inception++three.ws is a member of NVIDIA Inception, NVIDIA's programme for startups building on accelerated+computing, accepted in July 2026. Every 3D generation lane runs on NVIDIA GPUs: a self-hosted Cloud+Run GPU fleet behind text-to-3D, rigging, and motion, plus a free hosted lane behind chat, vision,+embeddings, safety, and speech. When an attendee forges a lantern into the plaza today, or arrives+with a freshly rigged avatar, NVIDIA silicon did the work.++### Quicknode: accepted into the Quicknode Startup Program++three.ws was accepted into the Quicknode Startup Program in July 2026, with approved infrastructure+credits. Quicknode's globally distributed RPC endpoints are a rung in the platform's Solana RPC+failover chain, adding capacity and redundancy behind agent wallets, x402 settlement verification,+and live market data, with the platform rotating smoothly across providers to keep chain access+fast and resilient.++### AWS: AWS Partner++three.ws is an AWS Partner. The AWS Marketplace SaaS integration is built: customer resolution,+subscription lifecycle events, account linking, and entitlement checks, with usage then paid per+call over x402. The Marketplace listing itself is coming next. AWS Strategic Partnerships also+published a long technical guide to the agentic economy on the AWS Builder Center that uses the+three.ws stack as its worked example from end to end, covering the x402 payment handshake, the MCP+servers, agent-to-agent payments, on-chain agent identity, and 3D embodiment.++### Alibaba Cloud: live on the Alibaba Cloud International Marketplace++three.ws has a live listing on the Alibaba Cloud International Marketplace, with its own+[product listing](https://marketplace.alibabacloud.com/products/56724001/sgcmfw00036800.html),+a [storefront](https://marketplace.alibabacloud.com/store/3247293.html), and an+[editorial feature](https://marketplace.alibabacloud.com/doc/blog/detail/mplace-sgcmfw00036800.html)+published on the Alibaba Cloud Marketplace blog. Qwen models are first-class lanes in the+platform's multi-model brain router, so an agent can think on Qwen the same way it can think on+Granite.++### HackerNoon: publishing partner++HackerNoon is three.ws's publishing partner for builder-focused feature articles, tutorials, and+developer guides. Every three.ws announcement flows automatically from the platform's announcements+RSS feed into HackerNoon's drafts queue, where it goes through HackerNoon's editorial review and+carries a canonical link back to three.ws.++### How the programmes fit together++Seen from the plaza, the picture is coherent. IBM supplies the community and the enterprise AI+models the agents can think with. OpenAI's surfaces carry the 3D tools to ChatGPT users. Google+Cloud hosts the world and the platform. NVIDIA hardware generates the avatars and items. Quicknode+helps keep the chain reads flowing. AWS and Alibaba Cloud extend procurement and reach to enterprise+buyers. HackerNoon carries the story to developers. Partnership enquiries go to+**[email protected]**.++## How the world holds a crowd: the multiplayer architecture++A nine-hour meetup inside a live multiplayer world is a showcase for the engineering underneath it.+Here is how /play is built.++### An authoritative server on its own Cloud Run service++The worlds run on an authoritative [Colyseus](https://colyseus.io) server, deployed as a dedicated+Cloud Run service separate from the main web container. That separation exists because a+request-and-response API and a fleet of long-lived WebSocket connections scale differently, so each+gets the deployment shape it needs. One process hosts several room types: the open-world coin+communities on /play, the walkaround world, the Agora commons, AR presence, Coin Wars battles, the+Living Stages, and shared AR build rooms.++### Fifteen updates a second, sent as binary deltas++Clients send movement about 15 times a second. The server validates every update (a step clamp+that rejects implausible jumps, world bounds, and rate limits on names, messages, and moves), keeps+the authoritative state, and broadcasts only what changed. Each player is a compact set of primitive+fields covering position, motion, identity, cosmetics, and combat flags, encoded as a binary delta+so only the changed fields travel. A full room of 100 players costs each client roughly 40 KB per+second downstream, comfortably within a normal connection.++### Rooms that scale out++Players in the same coin are matched into the same room instances, and each room holds up to 100+clients by default. When a crowd outgrows one room, more instances spin up. With a shared Redis+registry, Colyseus matchmaking becomes cluster-aware, so rooms for the same coin spread across+multiple server instances. A public population endpoint aggregates the live headcount across every+world room, and that is the number the event surfaces read.++### Voice that stays light at any size++Spatial voice is peer-to-peer WebRTC. The server's role is to pass the connection handshake between+two people, and connections open only between players near enough to hear each other. That+proximity gating is both what makes it sound right and what keeps it efficient in a crowded plaza.++### Shared clocks, shared physics, and server-verified value++The day and night cycle, the event countdown, and the fireworks are all computed from a shared+clock, so everyone sees the same sky and the same show at the same moment with zero network+chatter. A Rapier character controller handles movement, ground contact, and jumps against real+geometry, and vehicles stream their transforms at the same 15 Hz rhythm as movement. Anything of+value (a boutique purchase, a paid wheel spin, the Meetup Laurel) is granted by the server, and+on-chain payments are re-verified against the confirmed transaction before an item is delivered.++### Durable worlds++Voxel builds, player profiles, cosmetics ownership, and the activity feed persist to a durable+store, so a community's world accumulates over time. A dropped connection rejoins cleanly into the+same coin's world.++[Add uptime or performance highlights observed today, if any.]++## What the format signals for $THREE watchers++For anyone tracking $THREE or the broader agents-and-3D-worlds thesis, today is a meaningful data+point. A user group on a major enterprise's community platform chose to hold its flagship event+inside the product itself, for a full workday, open to anyone with a link. That reflects confidence+from both the organizers and the builders that the platform can host a large, curious, technical+crowd and give it a great day.++It also shows the $THREE home town doing the job it was built for. The town is the front door for+newcomers, the venue for live events, the place where the $THREE-priced boutique and the Intel Kiosk+live, and the world whose jumbotron shows the community's running headcount. A crowd of thousands+spending the day there, fishing, building, driving, and asking questions about Granite and x402, is+the platform's community and its product meeting in one place.++And it shows reach beyond the usual audience. Most of today's crowd came for the open world itself,+alongside the user group's members, which means people who started the day curious about a+browser-based 3D world are ending it with a laurel on their avatar and a sense of what three.ws can+do.++## What comes next for the group++The organizers on both sides are already talking about turning today into a rhythm: more joint+posts in the group, more of three.ws's shipped work surfaced through IBM's channels, and a standing+invitation for the next build session to happen in-world again. three.ws is also exploring what+IBM's expanded Partner Plus marketplace programmes could mean for a partner its size.++IBM is ready to host a second event, and a full proposal for it is written. The leading idea is the+**Forge-Off Open**: a one-week open creation contest that anyone can enter in under a minute with one+sentence and no account. Go to the Forge, describe an object, get a real textured 3D model, and+publish it to the community board, where anyone can vote, again with no login. Five daily themes+walk newcomers through the whole product (make an object, give it a face and a name, make it move,+place it in your own room in AR, and bring it to the party in /play), and the week closes with a+crowning ceremony inside the three.ws world, complete with the countdown, fireworks, and a+commemorative wearable for everyone present. The proposal also sketches an optional builders+division for developers who want to go further with Granite. The date is still being set, and the+group's Events tab is the place to watch for it.-Strip away the fun and there's a real signal here for anyone tracking $THREE or the broader-agent-and-3D-worlds thesis: a large enterprise partner chose to run its user group's flagship event-*inside the product* rather than around it. That only works if the product can actually hold a crowd-for nine hours without breaking, which is itself a live stress test of the multiplayer architecture-(an authoritative Colyseus server on Cloud Run, 15 Hz binary delta sync, proximity-gated spatial-voice) in front of exactly the kind of technical audience that would notice if it didn't hold up.-[Note uptime/perf observations here if anything notable happened, otherwise omit rather than assert-it went flawlessly.]+Meanwhile, the world itself stays open at [three.ws/play](https://three.ws/play), and so does the+group.## Follow alongThe event runs until 5 PM Pacific today. Anyone can drop in: open [three.ws/play](https://three.ws/play),-click the pinned $THREE world at the top of the lobby, and you're in as an avatar in seconds, no-download, no account, no wallet required to watch. The event listing and the technical write-up-behind it are on the [Three.ws User Group on IBM-Community](https://community.ibm.com/community/user/usergroup?CommunityKey=e71510cc-d953-408f-9a1c-019f5c0a7016).+click the pinned $THREE world at the top of the lobby, and you are in as an avatar in seconds, right+in your browser, with no account or wallet needed to watch. Arrive while the event is live and the+Meetup Laurel is yours to keep. The event listing and the technical write-up behind it are on the+[Three.ws User Group on IBM Community](https://community.ibm.com/community/user/usergroup?CommunityKey=e71510cc-d953-408f-9a1c-019f5c0a7016).A full recap, with the final headcount and the best moments from the day, follows once the doorsclose.-## The paper trail, for readers who want to verify any of this+## The paper trail, for readers who want to explore further-- **The user group itself:** [Three.ws User Group on IBM Community](https://community.ibm.com/community/user/usergroup?CommunityKey=e71510cc-d953-408f-9a1c-019f5c0a7016), the only project-specific group of its kind on the platform.+- **The user group itself:** [Three.ws User Group on IBM Community](https://community.ibm.com/community/user/usergroup?CommunityKey=e71510cc-d953-408f-9a1c-019f5c0a7016), a dedicated project group on the platform.- **Today's event listing:** [event description on IBM Community](https://community.ibm.com/community/user/events/event-description?CalendarEventKey=25d71799-16b5-4342-b2e5-019fcf9622ca&CommunityKey=e71510cc-d953-408f-9a1c-019f5c0a7016).- **The meetup announcement**, written by the group's IBM organizer: [Join the Three.ws User Group's First In-World Meetup This Friday](https://community.ibm.com/community/user/blogs/jessica-swanson/2026/08/04/join-the-threews-user-groups-first-in-world-meetup).-- **The group's welcome post**, when it launched in July: [Welcome to the Three.ws User Group](https://community.ibm.com/community/user/blogs/jessica-swanson/2026/07/14/welcome-to-the-threews-user-group-building-ai-agen).-- **The full technical write-up** behind the event: [Inside three.ws: a technical tour](https://community.ibm.com/community/user/discussion/community-meetup-inside-threews-join-us-on-the-three-server-at-threewsplay).+- **The group's welcome post**, from its July launch: [Welcome to the Three.ws User Group](https://community.ibm.com/community/user/blogs/jessica-swanson/2026/07/14/welcome-to-the-threews-user-group-building-ai-agen).+- **The full technical write-up** behind the event: [Community Meetup Inside three.ws: Join Us on the $THREE Server at three.ws/play](https://community.ibm.com/community/user/discussion/community-meetup-inside-threews-join-us-on-the-three-server-at-threewsplay).+- **The June live build** in IBM's Global AI & Data Science community: [Building 3D AI Agents Live](https://community.ibm.com/community/user/events/event-description?CalendarEventKey=2767712c-6efd-47dc-aaeb-019ec4126e27&CommunityKey=f1c2cf2b-28bf-4b68-8570-b239473dcbbc).- **The partnership, independently reported:** [Business Insider](https://markets.businessinsider.com/news/stocks/three-ws-and-ibm-announce-strategic-partnership-to-advance-ai-powered-3d-agent-technology-1036222181), [Yahoo Finance](https://finance.yahoo.com/sectors/technology/articles/ibm-extends-ai-narrative-three-010650764.html).-- **The live IBM integration pages:** [three.ws/ibm/hello](https://three.ws/ibm/hello) (partnership page), [three.ws/ibm/x402-demo](https://three.ws/ibm/x402-demo) (x402 demo).+- **The live IBM integration pages:** [three.ws/ibm/hello](https://three.ws/ibm/hello) (partnership page), [three.ws/ibm/x402-demo](https://three.ws/ibm/x402-demo) (x402 demo), [three.ws/constellation](https://three.ws/constellation) (watsonx Constellation).- **The open-source IBM connectors:** [`@three-ws/ibm-watsonx-mcp`](https://www.npmjs.com/package/@three-ws/ibm-watsonx-mcp), [`@three-ws/ibm-x402-mcp`](https://www.npmjs.com/package/@three-ws/ibm-x402-mcp) on npm.+- **The world and its economy:** [three.ws/play](https://three.ws/play), [three.ws/play/economy](https://three.ws/play/economy).+- **The partner map:** [three.ws/partners](https://three.ws/partners).- **The platform and social accounts:** [three.ws](https://three.ws), [github.com/nirholas/three.ws](https://github.com/nirholas/three.ws), [@trythreews](https://x.com/trythreews) on X.-- **The viral IBM exchange(s) on X:** [posted from @IBM](https://x.com/IBM/status/2061418285896269952), [and again](https://x.com/IBM/status/2061488909264040194).+- **The IBM exchanges on X:** [posted from @IBM](https://x.com/IBM/status/2061418285896269952), [and again](https://x.com/IBM/status/2061488909264040194).---diff --git a/docs/devto-mcp-fleet-post.md b/docs/devto-mcp-fleet-post.mdindex 8739487d0..5dfacfde2 100644--- a/docs/devto-mcp-fleet-post.md+++ b/docs/devto-mcp-fleet-post.md@@ -1,88 +1,119 @@---venue: dev.to (cross-post to Hashnode and Medium with canonical back to three.ws)account: three.ws / nichxbt-suggested_title: "We published 72 MCP servers. Here is what I would do differently."-description: "A practical post-mortem on running a large MCP fleet: why we ended up with 72 servers, the four traps that cost us the most (annotation blindness, stdio consent, OAuth discovery 404s, and free/paid entanglement), and the four rules we now build to."+suggested_title: "We published 72 MCP servers. Here are the principles we build them to."+description: "A practical guide from running a large MCP fleet: how we came to publish 72 servers, the four design principles that keep them safe and clear (enforcement on the server, consent where a person can see it, discovery metadata verified from outside, and free tools kept free by construction), how we organise the fleet for people and agents, and the one pattern that mattered most."tags: [mcp, ai, agents, opensource]canonical: https://three.ws/docs/mcpstatus: draft, owner approval required before posting (external-channel gate in CLAUDE.md)----# We published 72 MCP servers. Here is what I would do differently.+# We published 72 MCP servers. Here are the principles we build them to.-Not a brag. A confession, and then four rules.+Hi DEV! I work on [three.ws](https://three.ws), an open-source platform where AI agents get 3D bodies: you describe a character, and you get a rigged, animated avatar that can talk, act, and live on any web page.-I work on [three.ws](https://three.ws), an open-source platform where AI agents get 3D bodies. Along the way we ended up publishing **72 MCP servers in the official Model Context Protocol registry** under one namespace, and **91 npm packages**, 39 of them MCP servers in the main repo. That happened over months, one reasonable decision at a time, and the sum of those reasonable decisions is a discovery problem.+If you have not met MCP yet, here is the one-line version. The Model Context Protocol is a standard way to hand an AI assistant a set of tools. You run (or connect to) an MCP server, and Claude, ChatGPT, Cursor, or your own agent can call its tools: "generate a 3D model", "rig this mesh", "turn on the kitchen light".-If you are about to publish your second, fifth, or fiftieth MCP server, this is what I know now that I did not know then.+Along the way we published **72 MCP servers in the official Model Context Protocol registry** under one namespace, and **91 npm packages**, 39 of them MCP servers in the main repo. Avatars, 3D generation, scenes, voice, vision, market data, notifications, billing, naming, provenance, home control, and more: every capability that felt independently useful became its own server, because publishing a server is quick and MCP lets each one stand alone.-## How you get to 72 without ever deciding to+Running a fleet that size taught us a lot about making servers safe, clear, and easy to find. This post is everything I would hand to someone publishing their second, fifth, or fiftieth server.-Every capability that felt independently useful became its own server, because publishing a server is cheap and MCP has no first-class notion of a bundle or a namespace. Avatars, 3D generation, scenes, voice, vision, market data, notifications, billing, naming, provenance, home control, and so on. Each one was defensible. None of them was the result of a plan.+## The short version-The failure is not technical. All 72 work. The failure is that **a user cannot find the right one**, and neither can an agent, and the registry alone does not fix that.+1. **Enforce on the server.** Tool annotations describe; a server-side check decides.+2. **Ask for consent where a person can see it.** Keep the most consequential verbs on surfaces with a real human prompt.+3. **Verify your discovery metadata from outside, after every deploy.** It takes one curl.+4. **Keep free tools free by construction.** Different origin, different code, no payment imports.-## Trap 1: tool annotations describe, they do not enforce+Then organise the fleet by audience, share one typed tool layer across every server, and publish everywhere clients look.-MCP gives you `readOnlyHint`, `destructiveHint`, `openWorldHint`. Set them accurately; reviewers check, and inaccurate annotations are a listed rejection reason on the platforms with directories.+## Principle 1: annotations describe, the server decides-But understand what they are: **metadata for the client's UI, not a control.** They do not stop a tool. And the vocabulary has a real gap: `destructiveHint` covers "this deletes something", and does not distinguish between "this spends forty dollars" and "this unlocks a door in a house where a child is asleep".+MCP gives you `readOnlyHint`, `destructiveHint`, and `openWorldHint`. Set them accurately on every tool: reviewers check them, directory platforms rely on them, and clients use them to shape their UI.-We now write the server-side refusal first and the interface second. If a guard exists only in prompt text or in a hidden button, it is not a guard. An assistant can be argued out of a sentence; it cannot be argued out of a 403.+They are **metadata for the client's interface**, and they shine at that job. Enforcement is a separate job, and it belongs on the server. That matters most for actions with real-world weight: "this spends forty dollars" and "this unlocks a door" each deserve their own explicit, server-side rule.-## Trap 2: a stdio server cannot obtain consent, and should stop pretending+So we write the server-side check first and the interface second. A guard that lives in code holds whatever the conversation says. An assistant can be persuaded by a sentence; a 403 stays a 403.-We publish a server that gives any assistant control of a real Home Assistant house: read the house, list entities, list scenes, run one, call a service.+## Principle 2: consent belongs where a person can see it-The dangerous calls (locks, primarily) pass through a physical-action gate, and **over stdio that gate refuses outright**. Not "prompts the user". Refuses.+We publish a server that gives any assistant control of a real Home Assistant house: read the house, list entities, list scenes, run one, and call a service.-The reasoning took us a while to arrive at and now seems obvious. A local stdio MCP server has no user-visible surface of its own, no session, and no way to prove that a human saw a request and approved it. Any "confirm?" it emits is a string the model can read, generate, and answer by itself. That is not consent, it is theatre. So the dangerous verbs are only available 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 most consequential calls (locks, primarily) pass through one physical-action gate, and **over stdio, that gate keeps door-opening for surfaces where a person can approve it.** A local stdio MCP server has no screen of its own and no session, so a meaningful approval belongs on a surface where a real person is shown a real prompt. The local server explains this clearly when asked, and owners who want their own assistant to open one specific door can grant that single entity explicitly through an environment variable.-The pattern generalises past homes to any stdio server that can spend money, send messages as a user, or move something physical.+We tested it the way an attacker would: spawned the server as a child process, spoke MCP to it, and tried to smuggle `{confirmed: true}` into the service data three different ways. The door stayed locked each time, and the explicit per-entity allowance opened exactly the door it named.-## Trap 3: the OAuth discovery document nobody checks+The pattern applies far beyond homes, to any stdio server that can spend money, send messages as a user, or move something physical.-Our hosted server sits behind OAuth 2.1. The single most common reason a technically-correct MCP server fails a client's auth handshake is that `/.well-known/oauth-protected-resource` (or its neighbours) is not actually routed and answers 404, usually because the route table and the file layout disagree in production but not locally.+## Principle 3: verify discovery metadata from outside-Test it from outside your network, in production, with curl, after every deploy. It is a one-line check and it saves a week of "works on my machine" bug reports from users you cannot debug.+Our hosted server at `https://three.ws/api/mcp` sits behind OAuth 2.1, and a client's auth handshake starts by fetching `/.well-known/oauth-protected-resource` and its neighbours. Those documents are what make a correct server *discoverable* as a correct server.-## Trap 4: free and paid entangled in one server+So we check them from outside our network, in production, with curl, after every deploy:-We ship a free 3D server and a paid one. The free one has **no payment code in it at all.** Not disabled, not feature-flagged: absent. Different origin, different codebase, different deploy.+```bash+curl -s https://three.ws/.well-known/oauth-protected-resource+```++It is a one-line check, it confirms the route table and the file layout agree in production exactly as they do locally, and it gives every client a smooth first connection.++## Principle 4: keep free tools free by construction++We ship a free 3D server and a paid one. The free one contains **no payment code at all**: different origin, different codebase, different deploy. Its claim to be free is something anyone can verify by reading its import list, which makes it a claim that stays true over time and makes directory review straightforward.++We allow one deliberate crossover, and it runs in the generous direction: a few assurance tools on the **paid** server are permanently free. The physics-readiness grade (`grade_sim_readiness`) is free, read-only, and idempotent on every track, because a free check gets run on every asset, which is exactly where it does the most good.++## How we organise the fleet-This started as a review-friendliness decision (the directories reject anything that looks like it might charge under false pretences, and "we present a call as free and then charge" is a listed rejection reason). It turned out to be an engineering win too: a claim you can verify by reading an import list is a claim that stays true, and a flag that gates payment is a flag somebody will flip in the wrong environment eventually.+**1. One tightly scoped server per audience.** Our ChatGPT-facing server (`https://three.ws/api/mcp-chatgpt`) is exactly eight 3D tools and the model viewer, nothing else: keyless, no wallet, no account. Directories reward tightly scoped apps, so we submit one focused server per directory and document the rest as direct connections.-The one exception we allow runs the other way, and it is deliberate: a couple of tools on the **paid** server are permanently free, because they are assurance checks. An asset-grading tool that costs money is a tool nobody calls, and a tool nobody calls prevents nothing.+**2. One free studio server for every MCP client.** `https://three.ws/api/mcp-studio` carries fourteen keyless tools: the 3D tools, a ready-made asset catalog, and persona tools that turn a rigged model into a living agent body that speaks with lip-sync, emotion, and gesture.-## The four rules we build to now+**3. One hosted server for clients that want everything**, behind real OAuth 2.1, with discovery metadata verified on every deploy (Principle 3).-**1. One tightly scoped server per audience, not per capability.** Our ChatGPT-facing server is exactly the 3D tools and nothing else: eleven of them, keyless, no wallet, no account. The directories reward tightly scoped apps and reject generic ones, and thirty-seven separately submitted servers read as directory spam even when each one is good. Submit one, document the rest as direct connections.+**4. Typed tool authoring, shared across servers.** We publish `@three-ws/tool-sdk`: `defineTool` declares a tool's identity, Zod schemas, and permission manifest once (JSON Schema is derived automatically), `defineExecutor` routes every call through one entry point that validates params, enforces the declared rate limit, and normalises success and failure into one result shape, and `toMcpTools` adapts the result into the registration shape our servers use. One error shape across every server means an agent learns it once and handles all of them well.-**2. One hosted server for clients that want everything**, behind real auth, with working discovery metadata.+**5. Publish where clients look.** The official registry is the foundation: our servers live under `io.github.nirholas/*`. From there they are indexed on PulseMCP, Glama, and the LobeHub MCP marketplace, and installable as Claude Code plugins from our own plugin marketplace. Each surface brings a different audience, so we treat distribution as part of shipping.-**3. Typed tool authoring, shared across servers.** We publish `@three-ws/tool-sdk` (`defineTool`, `defineExec`) so annotations, schemas, and error shapes cannot drift from server to server. Fifty hand-written servers will disagree about error shape by the third one, and an agent handling five different error conventions handles none of them well.+## The one pattern that mattered most++If you take a single idea from this post, take this one.++A text-to-3D tool naturally answers with a **URL to a binary file**. A human clicks it and sees a model. An agent reads text and images, so we shipped a tool that renders a model into frames returned as MCP image content blocks. Now the agent can look at what it made, judge it, and iterate.++```bash+curl -s -X POST https://three.ws/api/3d/look \+ -H 'content-type: application/json' \+ -d '{"glb_url":"https://three.ws/avatars/cesium-man.glb"}'+```-**4. Publish where clients actually look.** The official registry is necessary and not sufficient. Ours are also indexed on PulseMCP and Glama, exposed through a LobeHub plugin manifest served from our own domain, and shipped as plugins in an editor plugin marketplace. Discovery is distribution, and distribution is not automatic.+It was a weekend of work and it transformed what the pipeline can do, because a loop thrives on a signal the agent can perceive. Pair it with `refine_model` (describe a change in words, get a new version with a branchable lineage) and you have a full generate, look, judge, refine cycle inside any MCP client.-## The one thing that mattered more than all of it+**Any tool that hands an agent a binary benefits from a companion that renders it into the agent's own modality.** PDFs, spreadsheets, audio, CAD, compiled artifacts. Give your agent a way to perceive its own output and it moves from guessing to iterating.-If you take a single idea from this post, take this one instead of anything about fleets.+## Partners across the fleet-Every text-to-3D API, ours included, answered tool calls with a **URL to a binary file**. A human clicks it. An agent cannot read it. So we shipped a tool that renders a model into frames returned as MCP image content blocks, and the agent can finally look at what it made, judge it, and iterate.+three.ws takes part in eight partner programmes, and several of them meet the MCP fleet directly:-It was a weekend of work and it changed what the pipeline can do, because a loop needs an error signal and a binary URL is not one.+- **OpenAI (Select Partner).** The keyless 3D Studio connector brings three.ws 3D tools into ChatGPT, rendered interactively inline, and our custom GPT calls the same capabilities through an Actions contract. We also publish Spatial MCP, an open, CC0 response shape that makes a 3D scene a native MCP result, with three.ws as the reference implementation.+- **IBM (Business Partner).** The IBM Granite x402 MCP lets an MCP client reach Granite inference and settle per call from a wallet it already controls. Our Granite tools are independent developer tools built on IBM's publicly available Granite models.+- **Alibaba Cloud.** Our community-built `@three-ws/alibaba-cloud-mcp` exposes Qwen chat, embeddings, and model discovery on your own DashScope account to any MCP client, and Qwen models are first-class lanes in the platform's model router. three.ws is live on the Alibaba Cloud International Marketplace.+- **NVIDIA (Inception).** Every 3D generation tool in the fleet runs on NVIDIA GPUs, and NVIDIA-hosted models serve chat, vision, embeddings, and speech behind the scenes.+- **Google Cloud.** three.ws is a member of Google Cloud for Web3 Startups. Every hosted MCP server in this post is served from Cloud Run.+- **AWS (Partner), HackerNoon (Media), and Quicknode (Infrastructure)** complete the eight. HackerNoon syndicates our engineering posts, and Quicknode adds capacity to the Solana RPC chain behind agent wallets.-**Any tool that hands an agent a binary needs a companion that renders it into the agent's own modality.** PDFs, spreadsheets, audio, CAD, compiled artifacts. If your agent cannot perceive its own output, it is guessing, and no amount of prompt engineering fixes that.+These are programme designations; the views here are our own. The full map is at [three.ws/partners](https://three.ws/partners).## Try any of it```bash-# 11 keyless 3D tools, no account+# 14 keyless tools, no accountcurl -s https://three.ws/api/mcp-studio \-H 'content-type: application/json' \+ -H 'accept: application/json, text/event-stream' \-d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'```Everything is Apache-2.0 at [github.com/nirholas/three.ws](https://github.com/nirholas/three.ws). The MCP docs are at [three.ws/docs/mcp](https://three.ws/docs/mcp).-If you publish MCP servers at any scale, I would like to hear how you handle namespacing and discovery. I do not think our answer is right; it is only the one that worked.+If you publish MCP servers at any scale, I would love to hear how you handle namespacing and discovery. This approach works well for us, and I am always keen to compare notes.diff --git a/docs/google-cloud-community-post.md b/docs/google-cloud-community-post.mdindex 8cad037a1..520f05b96 100644--- a/docs/google-cloud-community-post.md+++ b/docs/google-cloud-community-post.md@@ -1,84 +1,121 @@---venue: Google Cloud Community (Medium publication) / Google Cloud Community forumsaccount: three.ws (official)-suggested_title: "One container, 115 scheduled jobs, and a GPU fleet that sleeps: an AI platform on Cloud Run"-description: "How three.ws serves a static frontend, a route table, every API handler, and a fleet of open 3D model GPUs from Cloud Run: the single-container decision, Cloud Scheduler as the cron plane, Vertex AI as the reliability anchor in a free-first model chain, and the three deploy gates we added after each one caught a real outage."+suggested_title: "One container, 125 scheduled jobs, and a GPU fleet that sleeps: an AI platform on Cloud Run"+description: "How three.ws serves a static frontend, a route table, every API handler, and a fleet of open 3D model GPUs from Cloud Run: the single-container decision, Cloud Scheduler as the cron plane, per-lane GPU floors and a keep-warm cron, Vertex AI as the reliability anchor in a free-first model chain, and the deploy gates that check every release before it ships."tags: [cloud-run, cloud-scheduler, vertex-ai, gpu, generative-ai]status: draft, owner approval required before posting (external-channel gate in CLAUDE.md)----# One container, 115 scheduled jobs, and a GPU fleet that sleeps+# One container, 125 scheduled jobs, and a GPU fleet that sleeps-three.ws is an open-source platform where you describe a character and get a rigged, animated 3D agent you can embed anywhere. It runs on Google Cloud, and three.ws is a member of Google Cloud for Web3 Startups. This is the infrastructure write-up: what runs where, which decisions have held up, and the three deploy gates we added only after each one had already cost us an outage.+Hello, Google Cloud community! three.ws is an open-source platform where you describe a character in a sentence and get a rigged, animated 3D agent you can embed on any web page. It can talk, it can listen, and it runs entirely on Google Cloud. three.ws is a member of Google Cloud for Web3 Startups, which backs our compute and Vertex AI usage.-Everything is Apache-2.0 at [github.com/nirholas/three.ws](https://github.com/nirholas/three.ws), and `GET https://three.ws/api/version` returns the exact commit and Cloud Run revision production is serving, so any claim here is checkable against the code that serves it.+If you are new to the platform, picture three things running together: a website, an API with more than a thousand handlers, and a fleet of GPU workers that turn text and photos into 3D models. This post is the infrastructure write-up for all three: what runs where, the decisions we are happiest with, and the deploy gates that check every release before it reaches a user.++Everything is Apache-2.0 at [github.com/nirholas/three.ws](https://github.com/nirholas/three.ws), and `GET https://three.ws/api/version` returns the exact commit and Cloud Run revision production is serving, so any claim here can be checked against the code that serves it.++## The architecture at a glance++| Layer | Google Cloud service | What it does for us |+|---|---|---|+| Edge | Global External Application Load Balancer with Cloud CDN | TLS, the domain, and cached static assets close to users |+| App | One Cloud Run service (`three-ws-api`, `us-central1`) | The frontend, the route table, and every API handler |+| Jobs | Cloud Scheduler | 125 scheduled jobs, declared in the repo |+| GPUs | Cloud Run GPU services (NVIDIA L4, plus one RTX PRO 6000 Blackwell) | Open 3D model lanes, each its own service |+| Models | Vertex AI | Gemini as the reliability anchor of the text chain, Imagen leading the image ladder |+| Builds | Cloud Build | One gated pipeline from commit to revision |## The single-container decision-One Cloud Run service serves three things that are usually three deployments: the **static frontend**, the **route table**, and **every API handler**.+One Cloud Run service serves three things that are often three deployments: the **static frontend**, the **route table**, and **every API handler**.-The route table is the part worth explaining. Our routes live in a JSON config that the server reads on boot and splits into pre-filesystem and post-filesystem phases, which means a route change is a config change rather than a code change, and the same file is the source of truth for the scheduler sync described below. It is a slightly unusual shape and it has paid for itself repeatedly: there is exactly one place to answer "what serves this path".+The route table is the part worth explaining. Our routes live in a JSON config that the server reads on boot and splits at a filesystem marker into pre-filesystem and post-filesystem phases. A route change is therefore a config change rather than a code change, and the same file is the source of truth for the scheduler sync described below. There is exactly one place to answer "what serves this path?", and it has paid for itself many times over.Why one container rather than a service per concern:-- **A page and the API it calls share a deploy**, so a frontend that expects a new field cannot ship ahead of the field.-- **Cold-start count is one**, not seven. With serverless services, every additional service is another cold path for a user to hit.-- **The revision is the unit of truth.** "Which revision is serving this?" has one answer, and a rollback is one command.+- **A page and the API it calls share a deploy**, so a frontend and the field it expects always ship together.+- **One service to keep warm.** Every user path lands on the same warm instances.+- **The revision is the unit of truth.** "Which revision is serving this?" has one answer, and a rollback is one `gcloud run services update-traffic` command pointing 100% at a known-good revision.+- **The server imports each handler on first hit**, so a large API surface keeps its startup lean.-The trade is real: the container is larger than a per-endpoint function would be, and a hot path shares CPU with a cold one. For a product where the frontend and the API change together in almost every commit, it has been the right trade.+For a product where the frontend and the API evolve together in almost every commit, it is a great fit.## Cloud Scheduler as the cron plane-There are 115 scheduled jobs. They are declared in the same config file the server reads for routes, and a script syncs that declaration into Cloud Scheduler, so adding a job is a config change reviewed like any other.+There are 125 scheduled jobs. They are declared in the same config file the server reads for routes, and a script syncs that declaration into Cloud Scheduler, so adding a job is a config change reviewed like any other.-Two lessons from operating that many:+Two practices make that number easy to run:-**A dispatcher beats 115 schedule entries with independent opinions.** Several of our high-frequency jobs are invoked by one economy tick that fans out, with per-entry cooldowns deciding what actually fires. Sixty jobs each waking on their own minute boundary is sixty simultaneous cold starts on the same minute.+**A dispatcher for the high-frequency work.** Several of our most frequent jobs are invoked by one economy tick that fans out, with per-entry cooldowns deciding what actually fires. One tick on one warm instance handles the minute.-**Declare the schedule where the code lives.** A cron that exists only in the console is invisible to code review, invisible to `git log`, and impossible to recreate after an account change.+**Declare the schedule where the code lives.** A cron defined in the repo shows up in code review and in `git log`, and the whole schedule can be recreated from a clean checkout with one sync.++A few of the jobs that run on that plane: a GPU keep-warm tick, a six-hourly audit of every pinned model id against live provider catalogues, and a changelog publisher that posts each new release note to the community automatically after the deploy that ships it.## The GPU fleet, and why min-instances is a quota decision-The generation lanes run open 3D model families on their own Cloud Run GPU services (NVIDIA L4s, plus one RTX PRO 6000 Blackwell for the heaviest work): TRELLIS for image to 3D, Hunyuan3D for high-poly reconstruction, TripoSG for sketch to 3D, and around them the mesh pipeline (rigging, remeshing, texturing, segmentation, stylization, background removal, avatar reconstruction, text to motion, video to motion, video to scene). Thirty-two workers in total, most published as Docker images.+The generation lanes run open 3D model families on their own Cloud Run GPU services: TRELLIS for image to 3D, Hunyuan3D for high-poly reconstruction, TripoSG for sketch to 3D, and around them the mesh pipeline (rigging, remeshing, texturing, segmentation, stylization, background removal, avatar reconstruction, text to motion, video to motion, video to scene). More than thirty workers in total, most published as Docker images, all speaking one task shape and one shared bearer secret, so the router can treat every lane alike.++The interesting cost is the **weight load**, since a FUSE-mounted weight volume can take minutes to load cold. Each lane carries an explicit cold-start budget in the router (45 seconds for TripoSG, 60 for TRELLIS, 75 for Hunyuan3D), and that budget feeds the estimate a user sees. That leads to a counter-intuitive rule:++**`min-instances` is a quota decision, not a performance one.** Cloud Run GPU quota is per accelerator and per region, and it caps concurrent instances. Our `us-central1` L4 grant is 3, with a separate grant of 3 in `us-east4`. TRELLIS pins one always-warm instance and bursts to three, the rig lane pins one, Hunyuan3D runs at zero to keep burst headroom free, and the spiky sketch lane scales to zero. Different answers to the same question, each right for its lane.++A keep-warm job runs every 10 minutes during peak hours and holds an allowlist of scale-to-zero lanes resident, spending GPU-hours only when people actually generate. The allowlist lives in an environment variable, so it changes without a deploy. Two details worth copying: **a lane id in that allowlist that matches no known lane is reported and fails the tick**, so a typo surfaces immediately, and a test pins the keep-warm registry against the router's lane table, so every scale-to-zero lane stays reachable.++The two regions work as a pair. `us-east4` runs production text to motion plus standbys of the main 3D lanes, which gives a busy hour in `us-central1` somewhere to go. Our triage runbook also has a named signature for a saturated regional pool, so the first check on any "generation is slow" report is the pool. The operating rule: file the quota increase the moment you reach the ceiling, and route around it the same hour.++## Vertex AI as the anchor of a free-first chain++Every text completion on the platform runs through one shared failover chain that tries free providers first and reaches a paid key last. That chain is a dozen rungs deep, and two design rules matter more than the ordering:++**Every rung has a neighbour, and the bottom is keyless.** Two rungs need no key at all, so the chain always has somewhere to land, whatever keys are configured.++**Vertex Gemini is the reliability anchor.** When `GOOGLE_CLOUD_PROJECT` is set (every Cloud Run deploy), Gemini Flash-Lite on Vertex sits between the free tiers and the paid tail, authenticated by the service account and billed to our own cloud budget. Its capacity is ours to plan, which is exactly why a first-party cloud model belongs in a free-first chain: it is the rung whose behaviour we fully control.-The interesting cost is not the container start. It is the **weight load**: on a FUSE-mounted volume a cold load can stall for minutes before the job begins. Which produces the counter-intuitive rule:+Vertex also leads our text-to-image ladder: when the project is set, Vertex Imagen goes first for photoreal reference images, which then become the input to the 3D lanes.-**`min-instances` is a quota decision, not a performance one.** A regional L4 grant is finite. Pinning a warm instance on every lane starves the lanes that need to burst. So one lane pins one always-warm instance and bursts to three, another was explicitly moved to zero to free the shared regional pool, and the spiky lane scales to zero. Three different answers to the same question, correct per lane.+Pinned model ids get a scheduled audit too. Every six hours a job diffs our hardcoded model ids against the live provider catalogues and confirms with a live one-token call before flagging anything, so the team learns about a catalogue change well before a user would.-A keep-warm job holds an allowlist of scale-to-zero lanes resident during peak hours, with the allowlist in an environment variable so it changes without a deploy. One detail worth copying: **a lane id in that allowlist that matches no known lane fails the tick loudly** rather than warming nothing silently. A typo in a keep-warm config is otherwise invisible until someone complains about latency a fortnight later.+## Deploy gates that check every release-And when the regional pool is exhausted, requests do not fail with a message that says "quota". They fail slowly, in a pattern that reads like a model problem. We keep a named signature for it in the triage runbook, and the first check on any "generation is slow" report is the pool, not the model.+Our build is one command, `npm run build:gcp`, and its order is deliberate: conflict check, browser-graph check, a temporal-dead-zone check for Safari, sub-artifact builds, the frontend build, then the steps that write into the output directory *after* the frontend build refreshes it. Encoding that order in one command means every engineer and every agent builds the same way.-## Vertex AI as the anchor at the bottom of a free-first chain+Then `npm run deploy:gcp:submit` runs the gates, each checking one property mechanically before Cloud Build sees the code:-Every text completion on the platform runs through one shared failover chain that tries free providers first and only reaches a paid key last. That chain is a dozen rungs deep, and two design rules matter more than the ordering:+**1. Schema first.** The submit stops while any database migration is pending, so new code always meets the schema it expects.-**The chain can never have an empty rung.** Two rungs are keyless on purpose, so the bottom always exists even when every keyed provider is unset or throttled.+**2. An upload-context simulation.** We simulate the build-context upload and confirm every file the server imports at runtime is included, so the container that starts has every module it needs.-**Vertex Gemini is the reliability anchor**, billed to our own cloud budget rather than a third-party free tier, which means the chain's floor does not depend on somebody else's quota reset. That is the specific reason to put a first-party cloud model in a free-first chain: not because it is cheapest, but because it is the rung whose failure mode you control.+**3. The lockfile matches the install.** The image installs from `package-lock.json`, and the gate confirms the local `node_modules` matches it, so the code we test is the code we ship.-A related trap, which is not cloud-specific but bit us here: **model end-of-life is a silent outage.** An upstream family reached end of life and its rung began answering `410`. The chain fell through correctly, but the real fix was a scheduled job that diffs our hardcoded model ids against live provider catalogues, so we learn before users do. If you hardcode model ids anywhere, you owe yourself that job.+**4. Every API module imports cleanly.** A check imports every module under `api/` and confirms each one loads, because the server imports a handler on first request.-## Three deploy gates, each added after it would have saved us+**5. A synchronous CDN purge.** After the deploy, the purge runs synchronously. It takes about three seconds and means every post-deploy check reads fresh edge content.-Our build is a fixed chain and the order is load-bearing: conflict check, browser-graph check, a temporal-dead-zone check, sub-artifact builds, the frontend build, then the steps that write into the output directory *after* the frontend build wipes it. That last ordering fact has broken us more than once, so it is encoded in one command rather than in anyone's memory.+**6. A smoke sweep.** After the purge, a smoke test visits every page declared in our page registry against the live site.-The three gates that matter most, and what each one caught:+And the cheapest tool of all: the version endpoint that returns the running commit and revision. "Is this live?" is one curl.-**1. A migration gate before submit.** The build refuses to submit when a database migration is pending. Without it, new code shipped over an old schema, and production served handlers querying a column whose migration had never been applied. The error a user sees in that situation looks nothing like "we forgot a migration".+## Partners across the stack-**2. An upload-context simulation.** Before submitting, we simulate the build-context upload and fail if a file the server imports at runtime would be excluded by ignore rules. This exists because a revision shipped with one omitted module and answered every request, health check included, with a module-not-found error. The build was green. The container started. Nothing was wrong except one file that never got uploaded.+three.ws takes part in eight partner programmes, and several of them sit right inside this architecture:-**3. A synchronous CDN purge.** Our purge used to run asynchronously, and post-deploy checks then read stale edge content and reported phantom failures. Making it synchronous costs a minute and removes an entire category of "is it deployed or not" confusion.+- **Google Cloud.** three.ws is a member of Google Cloud for Web3 Startups. Cloud Run, Cloud Scheduler, Cloud Build, Cloud CDN, and Vertex AI carry the whole platform, and the programme backs that compute and Vertex AI usage.+- **NVIDIA Inception.** three.ws is an NVIDIA Inception member. Every GPU lane in this post runs on NVIDIA L4s or the RTX PRO 6000 Blackwell on Cloud Run, and NVIDIA-hosted models are among the free rungs of the text chain.+- **Quicknode (Infrastructure).** three.ws is in the Quicknode Startup Program, and Quicknode is a rung in our Solana RPC failover chain, the same rung-and-neighbour design as the model chain above.+- **OpenAI (Select Partner).** The keyless 3D Studio connector that brings our 3D tools into ChatGPT is served from this same Cloud Run container.+- **Alibaba Cloud.** Qwen models are first-class lanes in our model router, and three.ws is live on the Alibaba Cloud International Marketplace.+- **IBM (Business Partner), AWS (Partner), and HackerNoon (Media)** complete the eight.-The fourth, cheaper than all of them: a version endpoint that returns the running commit and revision. Nearly every "is this live?" conversation ends in one curl.+These are programme designations, and the views here are our own. The full map is at [three.ws/partners](https://three.ws/partners).## What I would tell someone starting the same build- **Put the route table in a file the server reads,** and let other tooling read the same file. One source of truth beats one convention.-- **Decide per lane whether a warm floor is worth it,** and write down why, because the reasoning is not recoverable from the config six months later.-- **Give every failover chain a keyless bottom rung.**-- **Add a gate the day after an incident, not the week after.** Each of the three above was written in the hours following the outage it now prevents, which is the only time the exact failure is still fresh enough to encode.-- **Publish the version.** It costs an afternoon and it retires an entire genre of conversation.+- **Decide per lane whether a warm floor is worth it,** and write down why next to the config.+- **Give every failover chain a keyless foundation and a first-party anchor.**+- **Encode every deploy property as a gate the build runs.** A gate turns knowledge into something every release checks automatically.+- **Publish the version.** It takes an afternoon and answers "what is live?" forever.-Free to try, no account and no key: [three.ws/forge](https://three.ws/forge) for 3D generation, `https://three.ws/api/mcp-studio` for the eleven-tool MCP server, and [three.ws/docs](https://three.ws/docs) for the rest.+Free to try, no account and no key: [three.ws/forge](https://three.ws/forge) for 3D generation, `https://three.ws/api/mcp-studio` for the fourteen-tool MCP server, and [three.ws/docs](https://three.ws/docs) for the rest.diff --git a/docs/home-assistant-community-post.md b/docs/home-assistant-community-post.mdindex 63648b5c5..49c335552 100644--- a/docs/home-assistant-community-post.md+++ b/docs/home-assistant-community-post.md@@ -1,30 +1,43 @@---venue: Home Assistant Community (community.home-assistant.io), category "Share your Projects!"account: three.ws (official) / nichxbt-description: "Forum post introducing the three.ws Home Assistant integration: a HACS custom integration that dials out over one WebSocket so a LAN-only install can be reached, an MCP server whose door-opening tools refuse over stdio, household roles enforced server-side, and a 3D agent that stands in a live model of your house."+description: "Forum post introducing the three.ws Home Assistant integration: a HACS custom integration that dials out over one WebSocket so a LAN-only install can be reached, an MCP server that keeps door-opening for surfaces where a person can approve it, five household roles enforced server-side, a voice loop with a confirmation grammar built for real rooms, and a 3D agent that stands in a live model of your house."tags: [custom-integration, hacs, mcp, voice, presence]status: draft, owner approval required before posting (external-channel gate in CLAUDE.md)----# I gave my Home Assistant a face, and spent most of the time making sure it cannot open my front door+# I gave my Home Assistant a face, and made the front door its best-guarded part-_Forum post for the [Home Assistant Community](https://community.home-assistant.io), category "Share your Projects!". Written first person for people who run HA, not for people who sell things to people who run HA._+_Forum post for the [Home Assistant Community](https://community.home-assistant.io), category "Share your Projects!". Written first person for people who run HA._-Hi all. I build [three.ws](https://three.ws), an open-source (Apache-2.0) platform for 3D AI agents: you describe a character, you get a rigged, animated 3D body that can talk, and you can embed it anywhere. For most of its life that character lived in a browser tab and the worst thing it could do was say something silly.+Hi all! I build [three.ws](https://three.ws), an open-source (Apache-2.0) platform for 3D AI agents. The short version for anyone new to it: you describe a character in a sentence, and you get a rigged, animated 3D body that can talk, listen, and be embedded on any web page.-Then I connected it to my house, and the whole design changed. This post is what I built, and much more importantly, what I refused to build.+A few months ago I connected one of those characters to my Home Assistant, and it turned out to be the most fun and the most carefully engineered thing I have built all year. Now my house has a friendly face. It stands in a live 3D model of my home, the bedroom lamp in the scene dims when the real one does, and I can ask it "good night" and watch it run the Bedtime scene my household already set up.-Short version: there is now a HACS integration that connects a LAN-only Home Assistant to a 3D agent that stands in a live model of your home and talks to you, plus an MCP server so **any** assistant (Claude, Cursor, your own) can read and drive your house. Locks are the interesting part, and the answer there is a flat no in several places on purpose.+This post walks through what it does, how to try it, and the design choices I am proudest of, especially around locks.-## What Home Assistant already does, and what I did not rebuild+**In one paragraph:** a HACS integration connects even a LAN-only Home Assistant to a 3D agent that lives in a model of your home and talks with you. A published MCP server lets **any** assistant (Claude, Cursor, your own) read and drive your house too. Physical actions that open the house, like unlocking a door, run only where a real person can see and approve them.-I wrote zero device code. Not "a thin abstraction", zero. Zigbee, Z-Wave, Matter, Thread, BLE, and the 1,500-plus integrations are the reason this project took weeks instead of years, and re-implementing any of it would have been vandalism. Since the `mcp_server` integration, HA also speaks Model Context Protocol natively, and three.ws already speaks MCP in around forty packages. The two halves met without either side inventing a protocol.+## What you get, at a glance-What genuinely does not exist anywhere, as far as I can tell, is the **face**: a real-time 3D presence that stands in a live model of your home, reacts to it, and speaks. That is the part I built.+- **A face for your house.** A 3D character standing in a live scene built from your own rooms, reacting as state changes.+- **Voice, hands-free.** A wake word that runs on your device, barge-in so you can interrupt, and spoken confirmation designed for real, noisy rooms.+- **Your scenes, understood.** Say "good night" and the agent finds the scene your household already built, even when it is called "Bedtime".+- **Sharing that matches real households.** Five roles, from the person who owns the house down to a wall display, each enforced on the server.+- **Privacy you can see.** One page shows everything a connected home stores, with export and delete buttons.+- **Any assistant you like.** The MCP server works with Claude, Cursor, or anything else that speaks Model Context Protocol.-## The LAN problem, and why the house dials out+## Built on what Home Assistant already does brilliantly-Most HA installs cannot be reached from the internet. No forwarded port, no public address, nothing to dial. That is not an edge case, it is the default install, and any integration that assumes otherwise is a cloud product wearing a local-first hat.+I wrote zero device code. Zigbee, Z-Wave, Matter, Thread, BLE, and the 1,500-plus integrations are Home Assistant's strength, and leaning on them is the reason this took weeks rather than years. Since the `mcp_server` integration, HA also speaks Model Context Protocol natively, and three.ws already speaks MCP across around forty packages, so the two halves met cleanly with no new protocol in between.++The platform also respects the control HA already gives you. Writes are scoped to exactly what you exposed to the LLM API in Home Assistant itself, so the outer boundary lives in HA's own exposure settings, where you already manage it. Your scenes and scripts are the macros: "good night" and "I'm leaving" resolve to `scene.turn_on` and `script.turn_on` on things you already built, and the agent only composes individual calls when no scene fits.++What I added is the **face**: a real-time 3D presence that stands in a live model of your home, reacts to it, and speaks.++## Designed for LAN-only installs: the house dials out++Most HA installs live on a home network with no forwarded port and no public address, and that is the default I designed for.So: **the house dials three.ws, and three.ws never dials the house.**@@ -33,30 +46,32 @@ One integration from HACS opens a single outgoing WebSocket and keeps it open.- Nothing listens on your network.- No port is forwarded and no firewall rule changes.- No tunnel daemon, no third-party service, no account anywhere else.-- **three.ws never receives a Home Assistant token.** The integration signs in to HA on your own machine with a credential it creates for itself, and that credential never leaves the house.+- **three.ws never receives a Home Assistant token.** The integration signs in to HA on your own machine with a credential it creates for itself, and that credential stays in the house.++The relay in the middle is small on purpose. It holds no database (ownership is proved by the signature on the install token the house presents), it holds no Home Assistant credential, and it forwards only the message types the protocol permits, in the direction it permits them. The integration enforces the same allowlist again at the house end, so each side checks the other.Install path, if you want to try it:-1. On three.ws, open `/smart-home`, choose **Connect a home that is only on my network**, and press **show me a code**. It has a ten-minute countdown.+1. On three.ws, open `/smart-home`, choose **Connect a home that is only on my network**, and press **show me a code**. The code is single use and has a ten-minute countdown.2. In HACS, add `https://github.com/nirholas/three-ws-home-assistant` as a custom repository, category **Integration**.3. Install **three.ws**, restart HA.4. **Settings, Devices and services, Add integration, three.ws.** Paste the pairing code.-If your HA already has a remote https address (Nabu Casa, or your own reverse proxy), skip all of that and connect with a long-lived token instead. The relay exists for the houses that do not, not as the default path.+If your HA already has a remote https address (Nabu Casa, or your own reverse proxy), you can skip all of that and connect with a long-lived token instead. Both paths lead to the same experience.-The threat model is written down and published rather than implied. Writing it is what produced two of the constraints above, which is an argument for writing one even when nobody asks.+The relay threat model is written down and published. Writing it shaped two of the properties above, and I recommend the exercise to anyone building on the home network.-## The part I care about: locks+## The part I am proudest of: locks-Here is where I expect this forum to have opinions, and I would genuinely like them.+Turning on a light and unlocking a door are different classes of action, so I designed them differently from the first line. My guiding principle: **a refusal belongs in code, where no conversation can talk it round.**-An LLM that can call `light.turn_on` is a convenience. An LLM that can call `lock.unlock` is a completely different product with a completely different failure mode, and the industry answer so far has been to put a sentence in a system prompt. **A system prompt is an argument, and an argument can be won by the other side.**+The guards live on the server, in four layers.-So the refusals live on the server, in four layers:+**1. The physical-action gate.** Anything that opens the house passes through one gate with one implementation, shared between the bridge and the MCP server so the two can never drift apart. Locks, garage doors, alarm panels, and anything HA marks as a security entity need explicit confirmation every time, until you grant a standing allowance for that one entity. Locking up never prompts.-**1. The physical-action gate.** Anything that opens the house passes through one gate with one implementation (shared between the bridge and the MCP server rather than two copies that drift). It is not a naming convention or a category filter; it is a code path.+One detail I found while building it, and it is a nice illustration of why the gate works on real targets rather than tool names: Home Assistant's Assist tool for turning things off documents that, for a lock, it performs an unlock. So the gate resolves every call to the real entities it touches and the service each one would actually perform, before anything runs. I confirmed this against a live instance with a lock exposed to Assist: the gate stopped the call, and with a real confirmation the door unlocked as intended.-**2. Over stdio, that gate refuses outright.** The published MCP server, `@three-ws/home-mcp`, gives any assistant five tools: read the house, list entities, list the scenes your household already built, run one, call a service. Point it at your HA:+**2. Over stdio, door-opening stays on surfaces with a person.** The published MCP server, `@three-ws/home-mcp`, gives any assistant five tools: read the house, list entities, list the scenes your household already built, run one, and call a service. Point it at your HA:```bashclaude mcp add home \@@ -65,40 +80,80 @@ claude mcp add home \-- npx -y @three-ws/home-mcp```-Ask it to unlock a door and it will decline and tell you why. A stdio MCP server has no user-visible surface of its own, no session, and no way to prove a human saw the request and approved it. Anything that presents itself as consent in that environment is a fiction, so unlocking is available only where a real person can be shown a real prompt.+Ask it to unlock a door and it will politely explain that this action lives on a surface where you can approve it. A stdio MCP server has no screen of its own and no session, so a real approval belongs on a surface where a real person sees a real prompt. If you want your own assistant to open one specific door, you grant that entity explicitly with `HOME_ALLOWED_ENTITIES`, and the allowance applies to exactly that entity and nothing else. I tested this by spawning the server as a child process and speaking MCP to it: an unlock with no allowance stayed locked, `{confirmed:true}` smuggled into service data stayed locked in all three variants I tried, an allowance for the kitchen door did not open the front door, and an allowance for the front door opened it and re-locked it.-**3. Household roles, enforced server-side.** A house has more than one person in it, and the old answer was to hand over your password. There are five roles now, each stating in plain words at the moment you pick it what it can and cannot do:+**3. Household roles, enforced server-side.** A house has more than one person in it. There are five roles, and each one states in plain words at the moment you pick it what it can do:-- Somebody who lives there can control everything and approve unlocking a door.-- A guest can turn the lights on and **can never** approve unlocking anything, no matter what an agent asks them. That refusal is enforced on the server, so there is no version of any client that could offer them the button.-- A guest or viewer can be scoped to just the kitchen, or just three devices, and **the rooms you did not give them are removed from what they receive**, not hidden on screen. Their app never learns those rooms exist.+| Role | Who it is for | What it can do |+|---|---|---|+| `owner` | The person who connected the house (exactly one per home) | Everything, including disconnecting |+| `admin` | Whoever runs the household | Everything except taking the house off the platform |+| `member` | Somebody who lives there | Act, confirm a guarded action, arrange the layout |+| `guest` | A visitor or house sitter | Lights and other ungated actions within their scope |+| `viewer` | A wall display or monitoring seat | Read their scope |++A few properties I especially like:++- A guest can turn the lights on and approving an unlock belongs to residents only. That rule is enforced on the server, so every client gets it for free.+- A guest or viewer can be scoped to just the kitchen, or just three devices, and **the rooms you did not give them are removed from what they receive**, not merely hidden on screen. Their app only ever learns about the rooms they were given.- Invitations work once, expire after a week, and can be withdrawn before anyone uses them.-- Removing somebody takes back every standing allowance they ever approved in the same instant, so a door cannot keep opening on the say-so of a person who has left.-- Every action in the home log is attributed to the person who took it, so "who did what" has a real answer.+- Removing somebody takes back 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" always has a clear answer.++**4. Voice, built for real rooms.** Hands-free is the interface that works when you are carrying groceries, so I gave it the most careful design of all. When a turn produces a guarded action, the agent speaks the whole action first ("This will unlock the Front Door. Say confirm to continue, or cancel to leave it alone"), shows the entity on screen with a countdown, and accepts one deliberate word: `confirm` and its close relatives. General affirmatives like "yeah" or "sure" are deliberately not part of the grammar, because those are the words a recognizer hears from conversations elsewhere in the room, and the token has to stand on its own rather than inside a longer sentence. The action itself was frozen on the server when the confirmation was minted, so a confirmation for one lock can only ever open that lock. On a device with no screen, the agent offers your phone for the approval.++## The voice loop, in a little more depth-**4. Voice, where consent is loosest.** Hands-free is the only interface that works when you are carrying groceries, and it is also the interface where a television in the next room can say "yeah". Confirming a physical action requires an intentional utterance, not an affirmative-sounding noise. This one took three rewrites and I still would not call it solved.+For the people here who enjoy the plumbing:-## Things I tried and did not ship+- **One microphone, opened once.** Voice activity detection is silero-vad (MIT) at 512-sample frames and 16 kHz, and the wake word is openWakeWord (Apache-2.0) running in the browser on onnxruntime-web.+- **The wake word stays on your device.** Only the utterance after the wake word is uploaded, and only to be transcribed. The sound of your voice is never stored.+- **Four pre-trained wake phrases ship:** Hey Jarvis (the default, and the one that does best in a noisy kitchen), Hey Mycroft, Alexa, and Hey Rhasspy (the smallest model of the four).+- **A voice satellite face.** The avatar also speaks the Wyoming protocol, so if you run an HA voice assistant, it can wear the agent's face in a room instead of being a speaker grille.-**Exposing the agent as a Matter device.** It is the obvious move, it would have been a good headline, and after measuring what it would actually cost and buy, I decided against it for now and published the reasoning rather than quietly dropping the thread. If someone here has done it and thinks I got the trade wrong, I would like to hear it.+## Verified against a real house-**A cloud-first pairing flow.** The first version had the platform dial the house. It worked in my house and in almost nobody else's, for the reasons in the LAN section.+Every claim above was checked against a real Home Assistant running in Docker, seeded with 122 entities across four areas, four locks, and two user scenes named "Bedtime" and "Away Mode":-## The rest, briefly+- The bridge client test suite passes end to end against that instance (37 tests, 7 of them live).+- `mcp_server` exposed 29 real tools, and a tool call turned on a real light.+- Saying "good night" in a house with no scene of that name resolved to `scene.bedtime` at 0.95 confidence, and the bedroom went dark in the 3D scene too (brightness 0.157, a warm `[255, 164, 82]`).+- A phrase with no matching scene runs nothing at all.+- The relay end-to-end test drove a house on a network the caller had no route to: 10 of 10 checks, including a real light toggled, a real door unlocked through the gate, and four allowlist checks holding.-- **A live 3D scene of your home** that the agent stands in, reacting to state as it changes. It is the reason to have a body at all: an agent that is *somewhere* in a house reads differently from a text box that mentions rooms.-- **A voice satellite face.** If you run an HA voice assistant, it can wear the agent's face instead of being a speaker grille.-- **Privacy as a page, not a policy.** See, export and delete everything a connected home stores, on one screen.-- **Honest status.** The status page can tell a dark house (yours is off, or asleep, or the internet is out at your end) from an actual outage on our side, and it says which. One unreachable home can no longer degrade the others, which was a real bug and a fair thing to be annoyed about.+The registry snapshot from that instance is checked in as a test fixture, so a Home Assistant registry change shows up as a test result long before it reaches anyone's house.++## Explored and documented: the agent as a Matter device++I prototyped presenting a three.ws agent as a Matter device using matter.js, and it commissioned into a real Home Assistant in 744 ms. I wrote the whole experiment up with its measurements, so anyone curious about the agent-as-a-device direction can start from data. The write-up is in the smart-home docs linked below.++## Everything else that ships today++- **A live 3D scene of your home** that the agent stands in, reacting to state as it changes. An agent that is *somewhere* in a house is a warmer thing to talk to than a text box.+- **A floorplan editor.** Draw a top-down plan, and the 3D scene follows it. A tray creates rooms and files devices into them in your own HA registry.+- **Privacy as a page.** See, export, and delete everything a connected home stores, on one screen. Room names, device names, and device states are never stored: they are read live and held in memory only while the connection is open. The action log defaults to 90 days and is yours to adjust, from one day up to ten years.+- **A clear status page.** It tells you whether your house is offline at your end or everything is running smoothly on ours, and every home's connection is isolated from every other home's.- **Language and units.** The whole surface reads in your language, in your units, at a touch size that works on a wall tablet, and the wall display stays awake.-- **The car**, because it is the same design problem: a voice-first agent that can reach your house from the road, with an Android Auto app built and a CarPlay scene waiting on Apple's entitlement.+- **The car.** Same design, on the road: three.ws Drive is a voice-first agent that can reach your house from the car, with an Android Auto app built and compiled and a CarPlay scene built into the iOS app. "Turn the porch light on" from the driveway is the whole point.++## Who we build with++three.ws takes part in eight partner programmes, and several of them touch this project directly:++- **Google Cloud.** three.ws is a member of Google Cloud for Web3 Startups. The platform and the relay your house dials into both run on Cloud Run.+- **NVIDIA Inception.** three.ws is an NVIDIA Inception member. Voice transcription in the home loop runs through NVIDIA Riva, and the 3D generation that builds the agent's body runs on NVIDIA GPUs.+- **OpenAI Select Partner.** Our free 3D Studio connector brings three.ws 3D tools into ChatGPT over MCP, and the same MCP approach is what makes `@three-ws/home-mcp` work with any assistant you choose.+- **Alibaba Cloud and IBM.** Qwen models are first-class lanes in the platform's model router, reached through Alibaba Cloud, and three.ws is an IBM Business Partner whose agents can think on IBM Granite models through watsonx.ai with your own IBM Cloud credentials.+- **AWS, HackerNoon, and Quicknode** round out the eight, covering cloud, developer publishing, and infrastructure.++These are programme designations, and the opinions in this post are my own. The full list is at [three.ws/partners](https://three.ws/partners).-## What I would like from this forum+## What I would love from this forum-1. **Is the stdio refusal right, or is it paternalistic?** My reasoning is that a local server cannot prove consent. The counter-argument I keep hearing is that it is the user's own machine and their own choice. I have not been convinced yet, but I am listening.-2. **Roles.** Five felt like the smallest set that covers real households (residents, guests, house sitters, kids, view-only displays). If you run a household where those five break down, tell me where.-3. **What should an agent never be allowed to do, even for the owner?** My current list is short: nothing that unlocks without a proven human prompt, and nothing that silently changes another person's access. I suspect this list should be longer.+1. **Your take on the stdio design.** My reasoning is that approval belongs where a person can see it, with per-entity allowances for owners who want their own assistant to open a specific door. I would love to hear how you would shape it for your setup.+2. **Roles in your household.** Five covers residents, admins, guests, house sitters, and wall displays. If your household has a shape I have not covered, I would like to add it.+3. **Your list of things an agent should always ask about.** Mine starts with unlocking and with changing another person's access. I would love your additions.Everything is Apache-2.0. The integration is at [github.com/nirholas/three-ws-home-assistant](https://github.com/nirholas/three-ws-home-assistant), the MCP server is `@three-ws/home-mcp` on npm, the platform is at [three.ws/smart-home](https://three.ws/smart-home), and the docs (including the relay threat model and the Matter write-up) are at [three.ws/docs/smart-home](https://three.ws/docs/smart-home).-Happy to answer anything, including hostile questions about why a 3D avatar belongs anywhere near a house. That last one is fair and I have a real answer for it: a home has rooms and objects, and an assistant that can be *somewhere* in it is easier to talk to than one that cannot.+Happy to answer anything, including why a 3D avatar belongs in a house. I have a real answer for that one: a home has rooms and objects, and an assistant that can be *somewhere* in it is easier and more pleasant to talk to.diff --git a/docs/huggingface-agent-feedback-loop.md b/docs/huggingface-agent-feedback-loop.mdindex a718b2e54..ee80ba3c3 100644--- a/docs/huggingface-agent-feedback-loop.md+++ b/docs/huggingface-agent-feedback-loop.md@@ -2,7 +2,7 @@venue: Hugging Face community article (huggingface.co/blog/three-ws/...)account: three-ws (organization)suggested_title: "Generate, look, grade, iterate: closing the feedback loop for agentic 3D"-description: "Third three.ws article for the Hugging Face community. Text-to-3D has been one-shot since it existed, because the model that generates an asset cannot perceive it. This is the loop we built to fix that: rendering results back into the model's own modality, a mechanical physics-readiness grade, structural diffing between iterations, and universal retargeting, all on open models running on our own GPUs."+description: "Third three.ws article for the Hugging Face community. This is the loop we built so an agent can judge and improve its own 3D output: rendering results back into the model's own modality, a mechanical physics-readiness grade, structural diffing between iterations, versioned refinement, and universal retargeting, all on open models running on our own GPUs."tags: [3d, agents, mcp, open-models, evaluation]house_rules: |Hugging Face blog rules as applied to our previous two articles: keep it AI-focused.@@ -13,26 +13,37 @@ status: draft, owner approval required before posting (external-channel gate in# Generate, look, grade, iterate: closing the feedback loop for agentic 3D-This is the third piece we have published here. The [first](https://huggingface.co/blog/three-ws/giving-ai-agents-bodies-and-wallets) argued that agents need bodies. The [second](https://huggingface.co/blog/three-ws/building-3d-ai-agents-end-to-end) walked the whole stack end to end. This one is about a single missing primitive that we think holds back every agentic 3D pipeline, ours included, and what happened when we built it.+Hello again, Hugging Face community! This is the third piece we have published here. The [first](https://huggingface.co/blog/three-ws/giving-ai-agents-bodies-and-wallets) argued that agents deserve bodies. The [second](https://huggingface.co/blog/three-ws/building-3d-ai-agents-end-to-end) walked the whole stack end to end. This one is about a single building block that we think every agentic 3D pipeline can benefit from, and what it unlocked for ours.-**The problem in one sentence: every text-to-3D API in existence answers with a URL to a binary file, and a language model cannot read a binary file.**+**The idea in one sentence: render every 3D result back into a modality the model can perceive, and the agent can judge its own work.**-That is why agentic 3D has been stuck at one shot since it began. The agent spends GPU time, receives a link, and has no way to tell a clean mesh from a melted one. It hands the link to a human and hopes. There is no error signal, so there is no loop, so there is no agency: just a very expensive random draw.+Here is why that matters, in plain terms. When an agent asks a text-to-3D model for "a ceramic robot", the answer is a `.glb` file: a compact binary of vertices, materials, and bones. People open it in a viewer. A language model reads text and images, so the natural next step is to show it the model as images. Once the agent can see what it made, it can say "the far side is unfinished, try again", and a single generation becomes a loop: generate, look, judge, refine, look again.Everything below is Apache-2.0 at [github.com/nirholas/three.ws](https://github.com/nirholas/three.ws), and every endpoint marked free is keyless.+## The loop at a glance++| Step | Question it answers | Tool |+|---|---|---|+| Generate | Make me a model | `forge_free`, `forge_avatar`, `text_to_avatar` |+| Look | What does it look like? | `look_at_model`, `@three-ws/see`, `POST /api/3d/look` |+| Grade | Can a physics engine use it? | `grade_sim_readiness`, `GET /api/sim-readiness` |+| Refine | Change it, and keep the history | `refine_model` with version lineage |+| Diff | Did that change actually do anything? | `@three-ws/glb-diff` |+| Animate | Make it move, whatever its rig | `@three-ws/retarget` |+## 1. Let the model look at what it made-The fix is embarrassingly simple once you say it out loud: render the result back into a modality the model actually perceives.+The step that changes everything is beautifully simple: render the result into a modality the model perceives.-Our `look_at_model` tool renders a GLB from several angles and returns the frames as **MCP image content blocks**, so a multimodal client renders them straight into the conversation. Alongside the frames it returns the geometry facts (triangle count, bounds, material count, whether it is skinned) and a plain-language reading of them.+Our `look_at_model` tool renders a GLB from several angles and returns the frames as **MCP image content blocks**, so a multimodal client renders them straight into the conversation. Alongside the frames it returns the geometry facts (triangle count, bounds, material count, whether it is skinned) and a plain-language reading of them, such as "12,400 triangles, a normal real-time budget for a hero prop or character". You can ask for up to six views (front, three-quarter, side, back, top, bottom) at sizes from 128 to 1024 pixels; the default is three-quarter, front, side, and back.Three ways in, because different consumers want different shapes:| You are | Use | You get ||---|---|---|| An MCP client | `look_at_model` on `https://three.ws/api/mcp-studio` | frames as image blocks, rendered inline |-| A Node program | `@three-ws/see` | `see(url)` returns views, stats, notes |+| A Node program | `@three-ws/see` | `see(url)` returns views, stats, notes, a viewer link, and an AR link || Anything with HTTP | `POST https://three.ws/api/3d/look` | JSON with a frame URL per angle |```bash@@ -41,81 +52,101 @@ curl -s -X POST https://three.ws/api/3d/look \-d '{"glb_url":"https://three.ws/avatars/cesium-man.glb"}'```-What changes is not the quality of any single generation. What changes is that the agent can now **judge** one, which means it can decide to refine, and every refinement is its own version with its own artifacts. Generate, look, judge, refine, look again.+In Node, `toMessageContent(look)` shapes a look into multimodal chat content (one labelled text block per angle, followed by the image), so the frames go straight into any vision-capable model's message. Pass `{ fetchImages: true }` to inline base64 for APIs that prefer bytes to URLs.-The generalisation is the part worth taking away, and it is not about 3D at all: **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 a mesh. Yours might be a PDF, a spreadsheet, an audio file, a CAD assembly, a compiled binary. If your agent cannot perceive its own output, it is not iterating, it is guessing.+What this changes is the agent's role: it can now **judge** a generation, which means it can decide to refine, and every refinement is its own version with its own artifacts.-## 2. A grade, so "good" means something mechanical+The broader lesson is not about 3D at all: **any tool that hands an agent a binary benefits from a companion that renders it into the agent's own modality.** Ours was a mesh. Yours might be a PDF, a spreadsheet, an audio file, a CAD assembly, or a compiled artifact. Give your agent a way to perceive its own output and it moves from guessing to iterating.-Perception gets you taste. It does not get you a specification.+## 2. A grade, so "good" means something mechanical-A renderer forgives almost everything; a rigid-body solver forgives nothing. A mesh that looks perfect on screen can sink through the floor in MuJoCo, behave as if hollow in Bullet, or turn out to be a metre tall because the generator fitted it to a unit box and nothing in the file says so. Every robotics, game-physics and world-model pipeline rediscovers those defects by hand, one asset at a time.+Perception gives an agent taste. A grade gives it a specification.-So we published the claim, mechanically, free, and CC0:+A physics engine asks a stricter question than a renderer: is the surface closed, is the winding consistent, is the volume positive, and are the dimensions real-world metres? A GLB has no field that says, so robotics, game-physics, and world-model pipelines each answer that question with their own checks. We published one mechanical answer, free, and CC0:```bashcurl "https://three.ws/api/sim-readiness?src=https://three.ws/avatars/cesium-man.glb"```+Cesium Man grades `simulation_ready`: 4,672 triangles, 1.51 m tall, about 0.054 cubic metres of volume, returned with its centroid and an inertia tensor at unit density.+Four verdicts:| Verdict | Meaning ||---|---|-| `simulation_ready` | Closed surface, consistent winding, positive volume, real-world extents. The only verdict that licenses trusting the reported mass. |-| `needs_scale` | Geometry is sound, only the units are missing. Multiply; mass properties scale with it. |-| `needs_repair` | Open, non-manifold, or inconsistently wound. Mass is reported but unreliable. |-| `unusable` | No triangles, or zero volume. |+| `simulation_ready` | Closed surface, consistent winding, positive volume, real-world extents. The verdict that licenses trusting the reported mass. |+| `needs_scale` | Geometry is sound, and only the units need setting. Multiply; mass properties scale with it. |+| `needs_repair` | Open, non-manifold, or inconsistently wound. Mass is reported as provisional. |+| `unusable` | Nothing to simulate: no triangles, or zero volume. |++A fifth value, `unreadable`, covers bytes that are not binary glTF 2.0 at all, kept deliberately distinct: one is a file that could not be read, the other is a valid file with nothing to simulate. Verdicts are content-addressed by the file's SHA-256, so identical bytes always get an identical grade and caching is trivially correct.-A fifth value, `unreadable`, covers bytes that are not binary glTF 2.0 at all, kept deliberately distinct: one is a broken file, the other is a valid file with nothing to simulate. Verdicts are content-addressed by the file's SHA-256, so identical bytes always get an identical grade and caching is trivially correct.+Three design decisions we would happily defend to anyone building evaluation infrastructure:-Two design decisions I would defend to anyone building evaluation infrastructure:+**Free, permanently.** It is also a free, read-only, idempotent tool on our *paid* MCP server, a deliberate exception to that server's pricing. A free check runs on every asset, and that is where it does the most good. The practical pattern is order of operations: an agent shopping for a prop can grade ten candidates for nothing and spend only on the one a solver can use.-**Free, permanently.** It is also exposed as a free tool on our *paid* MCP server, which is a deliberate exception to that server's pricing. An assurance check that costs money is a check nobody runs, and a check nobody runs prevents nothing.+**A spec, not a service.** [`specs/SIM_READINESS.md`](https://github.com/nirholas/three.ws/blob/main/specs/SIM_READINESS.md) is CC0, and the grader is a pure function you can vendor. If other people implement it and we never see the traffic, that is the outcome we are hoping for. A shared, machine-readable claim about physical usability is a great fit for the glTF ecosystem.-**A spec, not a service.** [`specs/SIM_READINESS.md`](https://github.com/nirholas/three.ws/blob/main/specs/SIM_READINESS.md) is CC0 and the grader is a pure function you can vendor. If this becomes a standard that other people implement and we never see the traffic, that is the successful outcome, not a lost one. The glTF ecosystem has no machine-readable claim about physical usability, and that hole gets filled either by a shared spec or by fifty incompatible internal scripts.+**Signed and versioned.** When a model is credentialed, a compact subset of its grade (the verdict, blockers, volume, longest axis, inertia, and convexity ratio) rides inside its signed content credential together with the grader version, `threews.sim.readiness.v1`. A signed grade is a durable claim about what that grader version measured, and a newer grader reports alongside it rather than overwriting it.-## 3. Diff, so "changed" means something structural+## 3. Refine, with a history you can branch-Between iterations, "did that actually change anything" gets asked constantly, and comparing two viewers by eye is a bad instrument at any scale.+`refine_model` takes a model and a change described in words ("make it metallic", "bigger helmet", "add wings") and runs a real anchored regeneration: the prior prompt is carried forward and folded together with the change, and an optional reference image of the current model anchors it as image to 3D.-`@three-ws/glb-diff` answers structurally: node graph, meshes, primitives, materials, textures, skins, animations, and what moved. It began as an internal debugging tool for the refine loop, and it is now the thing we reach for whenever a model is subtly wrong. If your pipeline mutates glTF anywhere (optimisation, retexturing, decimation, rigging), it is worth wiring in.+Every refinement is appended to an immutable **version lineage** returned with the result. The client passes that array back on the next call to extend the thread, or targets an earlier version with `parent_index` to **branch**. Reverting is a pointer move over the array, and the inline viewer shows the lineage as a version strip you can click to cross-fade between versions. For an agent, that means exploring two directions from the same parent is as easy as exploring one.-Together with the grade, this is what turns a refine loop into something you can actually evaluate: perception says whether it looks right, the grade says whether it is usable, and the diff says whether the last change did anything at all.+## 4. Diff, so "changed" means something structural-## 4. Retargeting, because the rig is never yours+Between iterations, "did that actually change anything?" comes up constantly, and a structural answer scales far better than comparing two viewers by eye.-The other half of "agentic 3D" is that the asset has to *do* something, and animation is where pipelines quietly fail.+`@three-ws/glb-diff` compares node graph, meshes, primitives, materials, textures, skins, and animations, with git-style rename and move detection. Its CLI emits JSON or a Markdown report sized for a pull-request comment, and `--fail-on <level>` turns it into a CI gate. It began as a debugging tool for the refine loop, and it is now what we reach for whenever a model deserves a closer look. If your pipeline mutates glTF anywhere (optimisation, retexturing, decimation, rigging), it is well worth wiring in.-Our constraint is that we never see the model first. It might come from our own lanes, from Mixamo, VRoid, Daz, Unreal, or a Blender export from 2019. So instead of a curated allowlist of supported rigs, we canonicalise bone names, then retarget onto the canonical set. The mapping covers Mixamo, Unreal, VRM and VRoid, VRM 1.0, Daz/Genesis, MakeHuman, Blender `.L`/`.R` and simple `shoulderL` conventions, and a new convention is one mapping entry plus a test, not a new code path. A model that genuinely cannot be skeleton-driven falls back to a default rig rather than a bind-pose T-pose, because a T-pose reads as a bug to every user and as "unsupported" to none of them.+Together they make a refine loop you can evaluate: perception says whether it looks right, the grade says whether it is usable, the lineage says where it came from, and the diff says what the last change did.-It is published on its own as `@three-ws/retarget`.+## 5. Retargeting, because every rig is welcome-## 5. The models underneath, and the fleet that serves them+The other half of agentic 3D is that the asset should *do* something, and animation is where a universal approach pays off most.-None of this is interesting without generation that works, and all of ours is open models on hardware we run:+We never see a model before it arrives. It might come from our own lanes, from Mixamo, VRoid, Daz, Unreal, or a Blender export from years ago. So instead of a curated allowlist of supported rigs, we canonicalise bone names, then retarget onto the canonical set. The mapping covers Mixamo, Avaturn, VRM 0.x and VRoid, VRM 1.0, Daz/Genesis, MakeHuman, the Unreal mannequin, HumanIK/Maya, Blender `.L`/`.R`, and simple `shoulderL` conventions. A new convention is one mapping entry plus a test. Rest-pose skew and hip up-axis differences are corrected automatically, every result reports its bone coverage, and a model that cannot be skeleton-driven falls back to a default rig, so every user sees a character in motion.-- **TRELLIS** for native single-hop image to 3D, taking both user photos and the synthesized view our text lane produces.+It is published on its own as `@three-ws/retarget`, with a crossfading runtime that layers one-shot gestures over a base loop.++## 6. The models underneath, and the fleet that serves them++All of this rests on generation, and ours is open models on hardware we run:++- **TRELLIS** for native single-hop image to 3D, taking both user photos and the view our text lane synthesizes.- **Hunyuan3D** for high-poly image-conditioned reconstruction, poly-budget aware.- **TripoSG** for sketch to 3D, and **TripoSR** in the family around it.- Plus the pipeline workers: rigging, remeshing, texturing, segmentation, stylization, background removal, avatar reconstruction from a photo, text to motion, video to motion, video to scene, and sign-language synthesis.-Thirty-two workers, most published as Docker images. They run as individual GPU services (NVIDIA L4s, plus one RTX PRO 6000 Blackwell for the heaviest lane), each speaking the same task shape, each with a failover chain so an unavailable model degrades quality rather than failing the request.+More than thirty workers, most published as Docker images. They run as individual GPU services (NVIDIA L4s, plus one RTX PRO 6000 Blackwell for the heaviest lane), each speaking the same task shape, each with a failover chain so a busy model hands the request to the next lane and the request still completes. Each lane also carries an explicit cold-start budget (45 seconds for TripoSG, 60 for TRELLIS, 75 for Hunyuan3D), which feeds the time estimate a user sees.++Three production principles we rely on:++**Decode meshopt once, at the front.** Most of our avatars ship with `EXT_meshopt_compression`, which every browser viewer handles well. Our Python workers read geometry with trimesh, so every worker that loads a caller's mesh decodes it at the entrance with a pinned `gltfpack`, and everything downstream reads plain geometry.++**Audit pinned model ids on a schedule.** A job runs every six hours, checks every hardcoded model id against the live provider catalogues, and confirms with a live one-token call before flagging anything, so the team hears about a catalogue change well before any user does.-Three production notes that will save someone a day:+**Give every failover chain a keyless foundation.** Two rungs in our text chain need no key at all, so the chain always has somewhere to land whatever keys are configured.-**Decode meshopt before anything reads geometry.** Most of our avatars ship with `EXT_meshopt_compression`. Every server-side consumer that reads geometry (ours are Python and use trimesh) must decode first, and the failure is confusing because the file loads perfectly in every browser viewer you test with.+## 7. Partners who make the loop possible-**Model end-of-life is a silent outage.** When an upstream family reached end of life on one of our free rungs, the rung answered `410`. The chain fell through correctly, but the real lesson was that a scheduled job should diff your hardcoded model ids against the live catalogues so you learn before users do.+three.ws takes part in eight partner programmes. The ones technically relevant to this loop:-**Never let a failover chain have an empty rung.** Two rungs in our text chain are keyless on purpose, so the bottom of the chain always exists even when every keyed provider is unset or throttled.+- **NVIDIA Inception.** three.ws is a member of NVIDIA Inception, NVIDIA's programme for startups building on accelerated computing. Every 3D generation lane above runs on NVIDIA GPUs, and NVIDIA-hosted models serve our chat, vision, embeddings, and speech lanes.+- **OpenAI Select Partner.** three.ws is an OpenAI Select Partner. The keyless 3D Studio connector brings this whole loop into ChatGPT, including `look_at_model` and `refine_model`, with models rendered interactively inline. Our open, CC0 Spatial MCP response shape makes a 3D scene a native MCP result, with three.ws as the reference implementation.+- **IBM Business Partner.** Agents can think on IBM Granite models through IBM watsonx.ai with their own IBM Cloud credentials, and our Granite-backed surfaces (vision, the Guardian trust layer, time-series forecasting) are independent developer tools built on IBM's publicly available Granite models.+- **Google Cloud.** three.ws is a member of Google Cloud for Web3 Startups. Production and the GPU fleet run on Cloud Run, and Vertex AI provides the Gemini and image lanes.+- **Alibaba Cloud.** Qwen models are first-class lanes in our multi-provider model router, so an agent can be pointed at a Qwen model as easily as any other.-## 6. What we would like the community to take, argue with, or fork+These are programme designations, stated here for technical context. None of these companies has reviewed this article.-- **`look_at_model` is the pattern, not the product.** Render your agent's output into your agent's modality. This costs a weekend and changes what your pipeline can do.-- **The readiness spec is CC0 and we want implementations, not traffic.** If you ship assets into a simulator, tell us where the four verdicts are wrong.-- **Retargeting without an allowlist is achievable**, and the mapping table wants conventions we have not hit.-- **Publish the negative results.** We evaluated approaches that did not survive contact (including exposing our agent as a smart-home device) and published the reasoning, and every time we have done that somebody has arrived with a better argument.+## 8. What we would love the community to take, build on, or fork-Free to try, no account and no key: [three.ws/forge](https://three.ws/forge) for generation, `https://three.ws/api/mcp-studio` for the eleven-tool MCP server, and the [three-ws organization](https://huggingface.co/three-ws) here for the avatar model repo and the viewer Space.+- **`look_at_model` is the pattern, not the product.** Render your agent's output into your agent's modality. It is a weekend of work, and it changes what your pipeline can do.+- **The readiness spec is CC0, and we would love implementations.** If you ship assets into a simulator, we would love your view on the four verdicts.+- **Retargeting without an allowlist works today**, and the mapping table welcomes conventions we have not met yet.+- **Publish your reasoning.** We publish the reasoning behind each design decision, including directions we explored and documented, and every time we have, somebody has arrived with a sharper idea.-three.ws is an NVIDIA Inception member and an IBM Business Partner; both are programme designations rather than endorsements, and neither company has reviewed this article.+Free to try, no account and no key: [three.ws/forge](https://three.ws/forge) for generation, `https://three.ws/api/mcp-studio` for the fourteen-tool MCP server (the 3D tools, the asset catalog, and the persona tools), and the [three-ws organization](https://huggingface.co/three-ws) here for the avatar model repo and the viewer Space.diff --git a/docs/ibm-community-governed-agents-post.md b/docs/ibm-community-governed-agents-post.mdindex 8555ab471..662aad12b 100644--- a/docs/ibm-community-governed-agents-post.md+++ b/docs/ibm-community-governed-agents-post.md@@ -1,8 +1,8 @@----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"+title: "When an agent can open your front door, governance becomes load-bearing: 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 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."+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, our partner ecosystem, and everything that shipped this quarter."status: posted 2026-09-18url: https://community.ibm.com/community/user/blogs/10058/2026/09/18/when-an-agent-can-open-your-front-door-governanceframing_notes: |@@ -17,54 +17,56 @@ framing_notes: |it is the section to cut first if the group's rule is applied strictly.----# When an agent can open your front door, governance stops being paperwork+# When an agent can open your front door, governance becomes load-bearing_Posted in the [Three.ws User Group](https://community.ibm.com/community/user/groups/community-home?communitykey=e71510cc-d953-408f-9a1c-019f5c0a7016) on IBM Community._-For most of this group's life, the agents we have been discussing lived in a browser tab. They had a 3D body, a voice, memory, and an identity, and the worst thing a bad decision could produce was a bad sentence.+Hello again, everyone, and a warm welcome to the members who joined since the meetup.-That 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.+If you are new here, a quick introduction. [three.ws](https://three.ws) is an open-source platform where AI agents have a 3D body, a voice, a memory, and an identity. You can describe a character in one sentence, get a rigged, animated 3D avatar back, give it a brain (IBM Granite on watsonx.ai is one of the options), and embed it on any web page with a single tag. For most of this group's life, those agents have lived in a browser tab, chatting, presenting, and guiding visitors around websites.-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.+This quarter they stepped out of the tab. 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. That is a genuinely exciting moment for a platform, and it puts one piece of the architecture at the centre of everything: governance.++This post is about that piece: **a governance model that is empowered 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 you can finish in an afternoon, a look at the partner programmes that power the platform, and a catch-up on everything else that shipped, because a lot has landed since we last met.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.+**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. Our formal partnership work with IBM is being built on the IBM platform, separately from these tools.**Contents**-1. The shape of the problem+1. The shape of the opportunity2. Granite Guardian as an action veto-3. The gate we built for houses, and why it refuses locally+3. The gate we built for houses, and why physical actions need a person4. The full watsonx.ai surface, endpoint by endpoint5. Build it yourself: a Granite-brained 3D agent in five steps6. Wiring watsonx.ai into your own client7. What else shipped this quarter8. The group, and what is next here9. One note on metering, for callers with no IBM Cloud account-10. Affiliations and listings, stated plainly+10. Our partners, and how each one connects to this work----## 1. The shape of the problem+## 1. The shape of the opportunityTake 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, 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, ordered and paid for without a human in the loop.+- **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, with a person's confirmation, locks.+- **A car.** A voice-first agent surface for the drive, where every interaction is spoken and answered out loud.+- **Manufacturing.** An API where a generated 3D model becomes a physical printed object, ordered and paid for end to end by an agent.-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.+Each one is useful on its own. Together they mean an agent's decisions now carry into the physical world, and that is exactly where good governance earns its keep. A sentence can be rephrased. A `lock.unlock` or a manufacturing order deserves a deliberate, verifiable decision.-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.+Prompt guidance, a carefully written system prompt, and a confirmation step in the interface are all worth having, and we use all three. We pair them with controls that live on the server, so every client gets the same guarantees, including any MCP client a developer connects tomorrow. Once you publish an MCP server, the server is the one place a rule holds for everyone.-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.+The foundation is the one enterprise software has trusted for decades: a policy layer between the reasoning and the action, which 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+## 2. Granite Guardian as an action veto-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.+Granite Guardian is often 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.@@ -77,6 +79,7 @@ curl -s https://three.ws/api/guardian/assess \```json{"model": "ibm/granite-guardian-3-8b",+ "provider": "watsonx","decision": "block","flagged": true,"topRisk": "jailbreak",@@ -89,25 +92,25 @@ curl -s https://three.ws/api/guardian/assess \}```-Four properties matter more than the classification itself.+Four properties matter even 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.+**It vetoes.** The same gate runs inline before an agent takes an autonomous value action, and a `block` verdict refuses the action. Treating the verdict as binding is what turns a classifier into a control.-**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.+**It also enforces a budget.** For autonomous sends, the governing call additionally enforces a dollar spend cap, so a request can be vetoed either for risk content **or** for exceeding the cap. Two kinds of "no" behind one gate is far easier to reason about than two separate gates. The cap is set in US dollars ($25 by default, configurable per deployment), so an operator sets it in the units they already think in, and one governing call returns a single decision covering both questions. Guardian catches *intent*; the cap catches *magnitude*.-**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".+**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 prefers to check for themselves. 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 wonderfully strong answer. Each record stores a SHA-256 digest of the assessed content rather than the content itself, so a ledger entry can be shared with an auditor without revealing the message it judged.-**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.+**Every verdict is real.** A `200` names the `model` and the `provider` lane that actually answered (watsonx.ai, or a self-hosted Granite Guardian lane when one is configured). When no lane is configured, the endpoint answers `503 guardian_unconfigured`, so a caller always knows whether Granite actually assessed the action. The whole integration is built without mock paths.-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".**+Every response is JSON with a named status: `400 bad_request` for a malformed body, `405 method_not_allowed`, `413` over 100 KB, `415` for a non-JSON content type, `429 rate_limited` (30 requests a minute per IP plus an hourly platform-wide ceiling on watsonx inference, charged only by real assessments), `502 guardian_failed` when every configured lane is unavailable, and the `503` above. The design principle underneath: **the gate fails closed.** Every outcome other than an `allow` leaves the action unexecuted.-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.+If you want the same thing in your own stack, 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+## 3. The gate we built for houses, and why physical actions need a person-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.+Home Assistant already owns the device layer beautifully: 1,500-plus integrations, every protocol we would otherwise have had to implement, around 90k stars, and native Model Context Protocol support through 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 three.ws adds 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.@@ -118,32 +121,51 @@ claude mcp add home \-- 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 interesting design decision is how physical actions are handled. Every call that would open the house passes through a physical-action gate, and **over stdio that gate declines by design.**-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 reasoning: a local stdio MCP server has no user-visible surface of its own and no session in which a person can be shown a request and approve it. So opening a door is reserved for surfaces where a real person sees a real prompt, and the local server tells the assistant clearly what it will do instead and why. The gate has one implementation, shared with [`@three-ws/home-bridge`](https://www.npmjs.com/package/@three-ws/home-bridge), so both packages enforce exactly the same rule.-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, that a rule 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.+- **Five roles**: `owner`, `admin`, `member`, `guest`, and `viewer`, each stating in plain language, at the moment you choose it, what it can do. A member who lives there can confirm a guarded action like unlocking a door. A guest is never asked to, whatever an agent requests, and that rule is enforced server-side, so no client, ours or anyone else's, would ever offer the button. Exactly one owner per home is a schema fact, enforced by a partial unique index.+- **Scoped access removes data.** 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 only ever knows about the rooms they were invited into.- **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.+- **Removing somebody revokes every standing allowance they ever approved**, in the same instant, so access always follows household membership.- **Attribution.** Every action in the home log names the person who took it.-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 live on a home network, 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 stays in 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 shaped two of the constraints above.++Connecting such a house takes four steps and a few minutes. In three.ws, open [three.ws/smart-home](https://three.ws/smart-home), choose **Connect a home that is only on my network**, and press **show me a code** (the code carries a ten-minute countdown). In Home Assistant, add the `nirholas/three-ws-home-assistant` custom repository in HACS, install the **three.ws** integration, restart, and paste the pairing code into **Settings, Devices and services, Add integration**. The three.ws tab flips to connected on its own within seconds, and from then on the house behaves exactly like any other connected home: the same rooms, the same scenes, and the same rules about who may confirm what. Houses that already have a remote https address, through Home Assistant Cloud or their own reverse proxy, can connect directly with a long-lived access token instead.++Three more decisions from the same wave, all published in full:-Two more decisions from the same wave, both worth reporting because they are the sort of thing that usually goes unpublished:+- **Voice, with a confirmation grammar built for physical actions.** The browser voice loop is live at [three.ws/voice/home](https://three.ws/voice/home), built on silero VAD and openWakeWord, both permissively licensed, both running on the listener's own machine and served from three.ws itself. Confirming a physical action requires an intentional utterance, so a background "yeah" picked up from a room is never treated as approval. Hands-free is the interface that works when you are carrying groceries, and the confirmation grammar is what makes it a safe one. The whole loop opens one microphone stream and reads it from every stage:-- **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.+ ```+ mic ─▶ silero VAD ─▶ openWakeWord ─▶ capture ─▶ /api/asr+ ─▶ agent turn (/api/chat, with the home tools)+ ─▶ /api/tts/speak ─▶ playback ─▶ lipsync ─▶ the 3D agent speaks+ ```-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.+ The agent turn in the middle is the same turn every other surface uses, so the same server-side rules, and the same Guardian gate for value actions, apply whether you type or speak.+- **Matter, prototyped and measured.** We built the agent as a Matter device on matter.js and published the full results. It commissioned into a real Home Assistant over plain IP, with no Bluetooth or Thread, in 744 ms; Home Assistant reached the agent in 328 ms and the agent reached Home Assistant in 531 ms; it ran at 73 MB of memory and 0.03% of one CPU, and it survived restarts of itself, the controller, and Home Assistant without re-commissioning. The highlight for this group: a guarded `lock.unlock` attempted through a Matter automation was held at `needs_confirmation`, and the door stayed locked until a person confirmed. The measurements are published so the next step starts from data.+- **A Home Assistant voice satellite can wear the agent's face**, so the box already sitting in the kitchen gets a body instead of a speaker grille.---## 4. The full watsonx.ai surface, endpoint by endpoint-Granite 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.+Granite 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. Granite is selected explicitly, whenever a request names the watsonx provider, and it sits alongside the platform's other brains in one router, so an agent owner can choose Granite per agent without changing anything else about the agent. Before an agent takes an autonomous money action, the same request is run through Granite Guardian inline, which is how section 2's gate and section 4's brain meet inside a single turn.++**How watsonx is wired.** The shared client mirrors the verified REST contract:++1. **IAM token exchange.** An IBM Cloud API key is exchanged at `iam.cloud.ibm.com` for a short-lived bearer token, cached per key and refreshed five minutes before expiry, with concurrent callers coalescing onto a single in-flight exchange. A warm instance pays the IAM round trip once, not per request.+2. **Project or space scoping** on every inference call, as watsonx requires.+3. **Version stamping**: `2024-05-31` for chat, embeddings, and vision, and `2025-02-11` for the Time Series Forecasting API.+4. **Real errors, surfaced.** Any IAM or upstream issue is reported with its true status and message (auth, quota, model not enabled in region), so a caller always sees the real cause.+5. **Every call has a deadline**: ten seconds and up to three attempts for the idempotent IAM exchange, one attempt with a 45 second deadline for inference.++The streaming chat endpoint returns an OpenAI-shaped SSE stream, so the avatar runtime reuses one delta reader across every provider.**The models we run, and what each is for:**@@ -155,7 +177,7 @@ Granite is a selectable brain for any three.ws agent. The chat proxy resolves wa| 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.+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, so every forecast is fed a fully populated context window.**Embeddings, standalone.** The same Granite vectors are available for your own semantic search or clustering:@@ -165,19 +187,19 @@ curl -s https://three.ws/api/watsonx/embed \-d '{"texts":["a witty trading assistant","a calm meditation guide"]}'```-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.+A batch is 1 to 96 texts, each up to 512 characters, and a warm process-local cache keeps repeat embeddings free (the response reports `cachedHits`). One detail worth copying if you build a similar endpoint: **the response always names its `model`.** Ours leads with Granite on watsonx.ai and has a free-first embedding chain behind it for full batches, and every vector in a single response comes from one provider, so `dimensions` is uniform within a response and the `model` field tells you exactly which provider answered. When no provider is configured at all it answers `503 embed_unconfigured`, and when the configured lanes are momentarily unreachable it answers a retryable `503 embed_unavailable` with the real upstream cause, so a caller always gets real vectors or a clear, actionable status.-**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.+**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 constellation is cached by a content hash of the agent set and the model, so repeat visits are instant, and `?refresh=1` forces a rebuild whenever you want one. Each search result carries a `home_url` pointing at the agent's canonical `/agents/:id` page, so a match is always one click from a conversation with that agent.-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.+The design here is the part I would point a reviewer at. Search stays in Granite's embedding space by design, because the stored vectors live there and every result should be measured in one geometry. When the embedder is momentarily unavailable, the endpoint adapts 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"`. **Adapt the method and say so, keeping each embedding space consistent**, 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.+**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.-**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.+**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: **a proof is only ever signed for a statement that passed Guardian.**-**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.+**Digital Twin.** Back-test and what-if simulation over the same forecasting stack. The back-test re-runs the forecast as of a past point and compares the prediction with what actually followed, reporting MAPE and directional-hit accuracy, so you see how well the model generalised. The what-if mode perturbs the recent conditioning window (a shock, a volatility scale, a momentum flip) and re-forecasts from the counterfactual baseline, then narrates the divergence, governed by Guardian.-**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.+**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 keeping the identity from representing the platform.```bashcurl -s https://three.ws/api/agents/identity-check \@@ -185,9 +207,9 @@ curl -s https://three.ws/api/agents/identity-check \-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.+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 say "you already have a similar agent". When watsonx is unconfigured it returns `{ configured: false, status: "unavailable" }` and allows the identity, a **deliberate fail-open** on a naming check. 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.+**Vision.** `ibm/granite-vision-3-2-2b` reads an avatar image into a complete identity in one multimodal call: appearance, vibe, persona, a suggested name, a one-line bio, tone tags, and a fitting voice descriptor. That is how a generated character acquires a described appearance rather than a filename. `GET /api/ibm/vision` returns a handful of real public avatars so you can try it with no upload, `POST` accepts either an image data URL (a canvas capture or an uploaded file, up to 6 MB) or an `imageUrl` for the server to fetch, and server-side image fetches are allowlisted to the platform's own asset host and a small set of content-addressed media hosts, with a byte cap and timeout.**The endpoint map:**@@ -202,7 +224,9 @@ It is auth-optional: anonymous callers get impersonation detection against all p| `GET/POST /api/ibm/vision` | Granite Vision reads an avatar into an identity || `POST /api/watsonx/embed` | Standalone Granite embedding vectors |-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.+Live pages: [three.ws/ibm/hello](https://three.ws/ibm/hello) and [three.ws/constellation](https://three.ws/constellation), where the Granite embedding space lays out live market data as a 3D star field. The Constellation always names the embedder that actually placed the stars and the model that actually wrote each analysis, renders a deterministic layout first and animates into semantic positions as the vectors land, and is fully keyboard operable: the canvas takes focus, the arrow keys walk the stars, Enter opens one, and Escape returns you to the galaxy. Every endpoint above is live and callable directly, which is why they are documented here as APIs.++Each surface also ships with an executable verification script in the repo, in two phases: an offline, deterministic phase that asserts the exact watsonx wire contract (model IDs, message shapes, verdict parsing, hash-chain integrity), and a live phase that makes a real call to watsonx.ai when credentials are present. `node scripts/verify-granite-guardian.mjs`, for example, covers risk classification, the spend cap, and the audit chain.---@@ -220,18 +244,18 @@ curl -s -X POST https://three.ws/api/3d/studio \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:+**2. Confirm the model is ready** for what you plan to build on top of it:<!-- runnable: 400 <your glb url> is a placeholder; a real GLB URL answers 200 -->```bashcurl "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).+Four verdicts, and the useful distinction is between `needs_scale` (geometry is sound, only the units are missing) and `needs_repair` (close the surface first, then the mass properties are reliable).-**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.+**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. The provider reports its status clearly, so you always know which brain is answering.-**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.+**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. 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:@@ -242,13 +266,13 @@ Four verdicts, and the useful distinction is between `needs_scale` (geometry isThere 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, 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).+A note on animation, because it is the step that brings a body to life: **there is no rig allowlist.** Bone names are canonicalised across Mixamo, 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. Any humanoid drives the same pre-baked clip library, and a model that is not skeleton-driven gets the default rig instead. 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:+If you would rather work with watsonx.ai directly, the open-source connector speaks to the watsonx.ai REST API with **your** credentials, with no intermediary backend, no telemetry, and no mock data:```bashWATSONX_API_KEY=… WATSONX_PROJECT_ID=… npx @three-ws/ibm-watsonx-mcp@@ -264,29 +288,33 @@ Five tools:| `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.+It is community-built: not an IBM product, and IBM neither operates nor endorses it.---## 7. What else shipped this quarter-The group has been quiet; the product has not. The parts most relevant to people here:+A lot has landed since the meetup. The parts most relevant to people here:++**An agent can see its own 3D output.** A `.glb` is a binary format built for renderers, so 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.-**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 ready-made asset catalog inside the free 3D server.** The keyless 3D Studio MCP server has grown to fourteen tools. The newest three search the CC0 prop library, the rigged characters, and the motion-clip library, and hand back paste-ready code, so an assistant can reuse an asset before it spends time generating one.-**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.** Physics engines ask more of a mesh than renderers do: a closed surface, consistent winding, positive volume, and real-world units. `GET /api/sim-readiness` answers whether a GLB is ready to use as a rigid body and, when it needs work, exactly which step comes next. Free, keyless, content-addressed by the file's SHA-256, 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.+**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 repair step that rebuilds the mesh as a solid and exports STL and 3MF, a safety screen that declines weapons, key duplicates, and third-party brand marks, a true-scale AR preview at the exact height you are ordering, a certificate of authenticity in the box, and optional limited editions.-**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.+**Avatar Studio can dress, rig, and walk an avatar,** as well as paint it. Alongside it: a restyling studio, a scene editor, pose and diorama tools, and an animation gallery the community authors into.-**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 "can it act?"** Liveness answers whether the process is up. An autonomous agent also needs preconditions the process does not see: a current model chain, provider credit, a funded wallet, a live data feed. We model those preconditions as vitals with `needs` edges, model actions as capabilities over them, and return the **root** blocker when a capability is unavailable. The engine is a zero-dependency, framework-agnostic package (`@three-ws/agent-vitals`), and if you run an agent fleet on any stack, I think you will find the idea useful.-**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.+**Reliability, published.** A "brownout" layer reports where every response's data came from and how fresh it is, and every fallback it lists has been executed for real, with the provider it protects against genuinely refusing, inside the same request path a user hits. The proof receipts are public.-**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.+**Testing.** A recorder that compiles a real user session into a Playwright spec which goes from red to green as an issue is fixed, so a report becomes a runnable experiment automatically.-**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.+**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 with an iOS app in the repo alongside it, and a car surface whose Android Auto app is compiled and whose native CarPlay scene is written, with Apple's entitlement request as the next step.++**Open-source packages for every idea above.** Each capability in this section ships as a standalone npm package under `@three-ws` with its own README, so you can adopt the piece you need, whether that is the vitals engine, the brownout client, the session recorder, or the terminal renderer, without adopting the rest of the platform.**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.@@ -294,9 +322,9 @@ The group has been quiet; the product has not. The parts most relevant to people## 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, and the thread index carries the deeper technical background, including walkthroughs of the Forge, auto-rigging, and the `agent-3d` web component.+For anyone new: this group has a lovely 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.+IBM has indicated readiness to host a second event, which we are thrilled about. 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. Choosing the date is the first decision, and this group is the right place to make it. If you have a format preference, say so in the comments.---@@ -304,7 +332,7 @@ IBM has indicated readiness to host a second event. The proposal on our side isScoped 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 an agent can consume the moment it can pay.+A typical MCP server wrapping a hosted model asks every caller to bring their own provider account, key, and billing relationship. That is perfect for a developer. An autonomous agent benefits from a path it can use mid-task, without signing up for anything. Our metered suite offers that path: 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 ||---|---|---|@@ -317,19 +345,20 @@ The two are separate packages on purpose. The credentials path remains the right----## 10. Affiliations and listings, stated plainly+## 10. Our partners, and how each one connects to this work++Several partner programmes sit underneath the platform this post describes, and I am glad to credit each one. Every designation is stated exactly as it is:-Since this post touches several vendor surfaces, here is the complete and precise position, with no upgrades:+- **IBM**: three.ws is an **IBM Business Partner**. Agents can think on IBM Granite models served through watsonx.ai using your own IBM Cloud credentials, and Granite Guardian is the governance layer this whole post is about. Everything under `/api/ibm/*` and the connector are independent developer tools built on IBM's publicly available Granite models: not IBM products, not partnership deliverables, and not endorsed by IBM. Our formal partnership work is being built on the IBM platform, and this user group is a community space three.ws moderates on IBM Community.+- **OpenAI**: three.ws is an **OpenAI Select Partner** in the OpenAI Partner Network, an independent member at the Select tier: not an OpenAI product, and not endorsed by OpenAI beyond the partner designation. The free 3D Studio connector in section 7 runs inside ChatGPT, keyless, and the same agents can choose Granite or an OpenAI model as their brain.+- **Amazon Web Services**: three.ws is an **AWS Partner**. The AWS Marketplace SaaS integration is built, deployed, and conformant with AWS's Concurrent Agreements requirements, and the Marketplace listing is coming, which will let enterprise teams bring three.ws in through their existing AWS procurement.+- **Google Cloud**: three.ws is a member of **Google Cloud for Web3 Startups**. Production and the GPU fleet run on Cloud Run, the crons on Cloud Scheduler, and Vertex AI provides the Gemini and image lanes in our model chain. Every endpoint in this post is served from there.+- **NVIDIA**: three.ws is a member of **NVIDIA Inception** (since July 2026), NVIDIA's programme for startups building on accelerated computing; it is a startup programme, not a partnership, an investment, or an endorsement. Every 3D generation lane in step 1 of section 5 runs on NVIDIA silicon: a self-hosted Cloud Run GPU fleet (L4 plus an RTX PRO 6000 Blackwell) behind text-to-3D, rigging, and motion.+- **Alibaba Cloud**: three.ws is **live on the Alibaba Cloud International Marketplace**, with a product listing, a storefront, and an editorial feature on the Alibaba Cloud Marketplace blog. Qwen models sit alongside Granite as first-class lanes in our multi-model brain router.+- **HackerNoon**: our **media partner**. three.ws announcements flow automatically from our RSS feed into HackerNoon's drafts queue, and pieces that publish there carry canonical URLs back to three.ws.+- **Quicknode**: accepted into the **Quicknode Startup Program** (July 2026), with approved infrastructure credits that add RPC capacity and redundancy behind the platform's agent wallets.-- **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 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.+The public map of all eight is at [three.ws/partners](https://three.ws/partners), and partnership enquiries go to [email protected].---@@ -346,10 +375,10 @@ 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?+# is this 3D asset ready for a physics engine?curl "https://three.ws/api/sim-readiness?src=https://three.ws/avatars/cesium-man.glb"-# the free 3D generation MCP server: 11 tools, no key, no account+# the free 3D generation MCP server: 14 tools, no key, no accountcurl -s https://three.ws/api/mcp-studio \-H 'content-type: application/json' \-d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'@@ -357,4 +386,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, 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.+The question I would most love this group to discuss: **how should a classifier and a capability model share the work of an action veto?** Guardian works well and the hash-chained ledger makes every verdict auditable. We also built a capability model, in the household roles, where the most sensitive verbs are simply unavailable to roles that should never use them. Our position is that the two complement each other beautifully: the capability model makes the boundaries explicit, and the classifier covers the situations no role table anticipates. I would love to hear how others divide that work in their own systems.diff --git a/docs/nvidia-forum-gpu-fleet-post.md b/docs/nvidia-forum-gpu-fleet-post.mdindex 9d49f150a..9b5c8f005 100644--- a/docs/nvidia-forum-gpu-fleet-post.md+++ b/docs/nvidia-forum-gpu-fleet-post.md@@ -2,72 +2,91 @@venue: NVIDIA Developer Forumscategory: AI & Data Science > NVIDIA NIM > Models (where all four approved posts live)account: nichxbt-suggested_title: "Running a free text-to-3D service on L4s: cold starts, keep-warm crons, and the quota arithmetic nobody publishes"-description: "The fourth three.ws write-up for the NVIDIA developer community: how a free, keyless text-to-3D and avatar service is served from a self-hosted Cloud Run GPU fleet of L4s plus an RTX PRO 6000 Blackwell, what a FUSE-mounted weight load costs on a cold start, why min-instances is a quota decision and not a performance one, and how the NIM free tier fits into a chain that must never have an empty rung."+suggested_title: "Running a free text-to-3D service on L4s: cold starts, keep-warm crons, and the quota arithmetic behind them"+description: "The fifth three.ws write-up for the NVIDIA developer community: how a free, keyless text-to-3D and avatar service is served from a self-hosted Cloud Run GPU fleet of L4s plus an RTX PRO 6000 Blackwell, how per-lane cold-start budgets shape the product, why min-instances is a quota decision rather than a performance one, and how the NIM free tier fits into a failover chain designed so every rung has a neighbour."tags: [nim, nemotron, inference]links_in_body: 2 (our Audio2Face topic and our retirement topic, both on this forum). Repo paths and three.ws are plain text on purpose; see the approval pattern in nvidia-visibility-map.md.images: 0-status: revised to the approval pattern 2026-09-22, owner approval required before posting (external-channel gate in CLAUDE.md)+status: revised to the approval pattern 2026-09-22 and reframed positively 2026-10-08, owner approval required before posting (external-channel gate in CLAUDE.md)----# Running a free text-to-3D service on L4s: cold starts, keep-warm crons, and the quota arithmetic nobody publishes+# Running a free text-to-3D service on L4s: cold starts, keep-warm crons, and the quota arithmetic behind them-I run three.ws, an open-source platform where you type a sentence and get a textured, rigged, animated 3D character. I have written here four times before, most recently about [a browser-tab digital human on Audio2Face-3D](https://forums.developer.nvidia.com/t/a-digital-human-in-a-browser-tab-streaming-audio2face-3d-onto-whatever-rig-the-visitor-brought/383953) and, before that, [what a retired NIM model id does to a fallback chain](https://forums.developer.nvidia.com/t/nvidia-nim-model-retirements-what-a-410-gone-does-to-a-fallback-chain-and-how-we-survive-it-now/383950).+Hi again, everyone. I run three.ws, an open-source platform where you type a sentence and get a textured, rigged, animated 3D character you can put on any web page. If you are new to it, the simplest way to picture it: a description goes in, and a little later a character that can walk, wave, and talk comes out, with the 3D generation running on NVIDIA GPUs.-This one is about the boring half that keeps the free lane free: the fleet. three.ws is an NVIDIA Inception member; that is a startup programme, not a partnership or an endorsement, and nothing below is an NVIDIA statement.+I have written here a few times before, most recently about [a browser-tab digital human on Audio2Face-3D](https://forums.developer.nvidia.com/t/a-digital-human-in-a-browser-tab-streaming-audio2face-3d-onto-whatever-rig-the-visitor-brought/383953) and, before that, about [how our fallback chain handles NIM model retirements](https://forums.developer.nvidia.com/t/nvidia-nim-model-retirements-what-a-410-gone-does-to-a-fallback-chain-and-how-we-survive-it-now/383950).-The thing I want to write down is the arithmetic, because every other "we run open models in production" post I read skipped it, and the arithmetic is where the design lives.+This post is about the half that keeps the free lane free: the GPU fleet. three.ws is a member of NVIDIA Inception, NVIDIA's programme for startups building on accelerated computing, and the views below are our own.-## The fleet+I want to write down the arithmetic, because the arithmetic is where the design lives, and I hope it is useful to anyone serving open models on granted GPU capacity.-Every generation lane runs as its own Cloud Run service on an **NVIDIA L4** in `us-central1`, plus one **RTX PRO 6000 Blackwell** for the heaviest work. They all speak one task shape (`POST /<endpoint>` returns a task id, `GET /tasks/:id` returns status and result) and share one bearer secret, which means the router does not care which model is behind a lane.+## The fleet, in plain terms++Every generation lane runs as its own Cloud Run service on an **NVIDIA L4**, plus one **RTX PRO 6000 Blackwell** for the heaviest work. Every lane speaks one task shape (`POST /<endpoint>` returns a task id, `GET /tasks/:id` returns status and result) and authenticates with one shared bearer secret, so the router can treat every model the same way and swap lanes freely.The lanes, and what each is for:-- **TRELLIS** (`model-trellis`): native single-hop image to 3D. Accepts a user's photo, and also the synthesized view that the text lane produces. Textured GLB out.-- **Hunyuan3D** (`model-hunyuan3d`): high-poly image-conditioned reconstruction, poly-budget aware.+- **TRELLIS** (`model-trellis`): native single-hop image to 3D. It accepts a user's photo, and also the view that our text lane synthesizes for a text prompt. Textured GLB out. This is the workhorse lane.+- **Hunyuan3D** (`model-hunyuan3d`): high-poly image-conditioned reconstruction, poly-budget aware, and the default engine for our `high` image tier.- **TripoSG** (`model-triposg`): sketch to 3D. A drawing plus a prompt naming it, untextured geometry out.- **TripoSR**, plus the mesh pipeline around all of them: rigging, remeshing, texturing, segmentation, stylization, background removal, garment generation, avatar reconstruction from photos, text to motion, video to motion, video to scene, and sign-language synthesis.-Thirty-four workers in total, most of them Docker images you can build and run yourself. The point of self-hosting was never cost alone: it is that a lane we host is a lane we can debug, and a free-tier vendor lane is a lane that changes under you.+More than thirty workers in total, most of them Docker images you can build and run yourself from `workers/`. Self-hosting gives us a lane we can tune end to end: the same image, the same weights, and the same behaviour every day.++## Cold starts are a model-load question++Container start time on Cloud Run is quick. Where the time goes is the **weight load**, and on a FUSE-mounted weight volume a cold load can take minutes before the first job begins.++So each lane carries an explicit cold-start budget in the router's lane table (`api/_lib/forge-tiers.js`): 45 seconds for TripoSG, 60 for TRELLIS, and 75 for Hunyuan3D, the largest in the fleet. That budget feeds the time estimate a user sees, so a cold lane gets a longer, accurate estimate rather than a guess.++Three consequences shaped the product.++**1. `min-instances` is a quota decision, not a performance one.** Min 1 everywhere would be lovely, but GPU quota on Cloud Run is per accelerator and per region, and it caps concurrent instances rather than services. Our `us-central1` L4 grant is 3, and `us-east4` has a separate grant of 3. In `us-central1`, TRELLIS pins one always-warm instance and bursts to three, the rig lane pins one, and that leaves headroom for TRELLIS to burst when traffic arrives. Hunyuan3D runs at min 0, a change we made on 2026-07-26 after measuring its traffic, which freed a slot for the lanes that needed it. TripoSG scales to zero because its traffic is spiky and its users are happy to wait for a sketch. Three different answers to the same question, each right for its lane.++**2. A keep-warm cron beats a bigger floor.** `api/cron/gpu-keepwarm.js` runs every 10 minutes during peak hours from Cloud Scheduler and holds an allowlist of scale-to-zero lanes resident. It is cheaper than raising a floor because it spends GPU-hours only during the hours people actually generate. Each lane in its registry records its region, its accelerator, and whether warming it is safe by default. Text to motion is warmed by default because it is the only GPU service in `us-east4`, so warming it shares a pool with nothing. The `us-central1` L4 lanes stay out of the default set so the TRELLIS burst headroom stays intact, and they join the moment that grant grows.++The allowlist is an environment variable (`FORGE_KEEPWARM_LANES`), so it changes without a deploy. Two details worth borrowing: **a lane id that matches no known lane is reported as `unknown_lanes` and marks the tick as failed**, so a config typo surfaces at the very next tick, and a test (`tests/cron-forge-lane-guards.test.js`) pins the keep-warm registry against the router's lane table, so every scale-to-zero lane with a cold-start budget is always reachable by the override.++**3. Show real progress during a cold start.** When a lane is cold, the user is told what is actually happening (the model is loading) with an estimate built from that lane's budget. Our text-to-3D path goes through an intermediate image, so we can also show the concept art the geometry model is about to sculpt. Showing something true and specific makes the wait feel shorter.-## Cold starts are a model-load problem, not a container problem+## The GPU pool as a first-class signal-The single most misleading metric in serverless GPU work is container start time. Ours is fine. The cost is the **weight load**, and on a FUSE-mounted weight volume a cold load can stall for minutes before the job even begins.+We treat the state of the regional L4 pool as a signal in its own right. Our triage runbook has a named signature for a saturated pool, and the first check on any "generation is slow" report is the pool, then the model.-Three consequences that shaped the product:+The operational rule I would give anyone building on a granted GPU pool: **file the quota increase the moment you reach the ceiling, and route around it in the same hour.** Lower a min-instance somewhere else, use the other region's grant, or queue behind existing capacity. That keeps the product moving at full speed while the request is reviewed.-**1. `min-instances` is a quota decision, not a performance one.** The obvious move is min 1 everywhere. You cannot: a regional L4 grant is small (ours is 3 in `us-central1`, with a separate grant of 3 in `us-east4`), and pinning warm instances on every lane starves the lanes that need to burst. So one lane pins an always-warm instance and bursts to three, another was moved to min 0 explicitly to free the shared pool, and the sketch lane scales to zero because its traffic is spiky and its users are patient. Those are three different answers to the same question, and the right answer is per-lane.+The second region is a big part of that. `us-east4` carries production text to motion plus standbys of TRELLIS, Hunyuan3D, and TripoSR, so a busy hour in one region has somewhere to go.-**2. A keep-warm cron beats a bigger floor.** A scheduled tick during peak hours holds an allowlist of scale-to-zero lanes resident, and the allowlist is an environment variable so it can change without a deploy. One detail worth stealing: **a lane id in that override that matches no known lane is reported back and fails the tick**, rather than quietly warming nothing. A typo in a keep-warm config is otherwise invisible until somebody complains about latency two weeks later.+## Failover per lane, with every rung backed by another-**3. Surface the cold start honestly.** When a lane is cold, the user is told a real thing (the model is loading) with a real estimate, not a fake progress bar that fills at a constant rate regardless of what is happening. Our text-to-3D path goes through an intermediate image, so we can also show the concept art the geometry model is about to sculpt. Showing something true makes the wait feel shorter than animating something false.+Every generation lane has a failover chain, so when one model is busy the request moves to the next lane and still completes. The same discipline runs on the text side, and that chain is where NIM sits.-## Quota starvation looks exactly like a bug+The text chain tries free rungs first, in order, and reaches a paid key only at the very end. NVIDIA NIM is one of those free rungs, on the free developer tier, pinned to `nvidia/nemotron-3-super-120b-a12b`, with `nvidia/nemotron-3-ultra-550b-a55b` and `nvidia/nemotron-3.5-lightning-30b-a3b` alongside it. Three design rules make it work:-Worth naming because it cost us a debugging session. When the regional L4 pool is exhausted, requests do not fail in a way that says "quota". They fail slowly, in a pattern that reads like a model problem or a network problem. We now have a named signature for it in our triage runbook, and the first check on any "generation is slow" report is the pool, not the model.+**Audit pinned model ids on a schedule.** `api/cron/free-model-audit.js` runs every six hours and checks every hardcoded model id against the live catalogues, NIM's Nemotron pins included. Because a catalogue listing and an account's callable set can differ, an id is only reported as gone after a live one-token call confirms it, and the ops channel hears about it before any user does. That is the practical result of the retirement post linked above.-The corollary, and this is the operational rule I would give anyone building on a granted GPU pool: **file the quota increase the moment you hit the ceiling, then route around it in the same hour.** Lower a min-instance somewhere else, use the other region's grant, queue behind existing capacity. Parking the feature on the quota request is how a two-day problem becomes a two-week one.+**Send reasoning models the right flag.** The Nemotron rungs are a reasoning family, so the chain sends `chat_template_kwargs: { enable_thinking: false }` to keep the answer in `content`, where the caller reads it. Normalising each provider's conventions is what lets every rung contribute a real answer.-## Failover per lane, and the rung that must never be empty+**Keyless rungs at the bottom.** Two rungs in the chain need no key at all, so the chain always has somewhere to land, whatever keys are configured.-Every generation lane has a failover chain, so an unavailable model degrades quality rather than failing the request. The same discipline runs on the text side, and that chain is the one where NIM sits.+The same NIM account serves more than chat: `meta/llama-3.2-11b-vision-instruct` for vision, `nvidia/nemotron-3-embed-1b` for embeddings, NemoGuard and Llama Guard for publishing safety, Magpie TTS over Riva gRPC for speech, and FLUX and TRELLIS through GenAI invoke. The full model-by-model map is in `docs/nvidia-models.md`.-The text chain tries free rungs first, in order, and only touches a paid key as a last resort. NVIDIA NIM is one of the free rungs (Nemotron, on the free developer tier). Two hard-won notes for anyone building a similar chain:+## How free and keyless stays sustainable-**Model end-of-life is a silent outage.** When a family we depended on reached end of life on NIM, the rung answered `410`. Our chain fell through correctly, and nobody noticed for two weeks. That story is the retirement post linked above, so I will not repeat it here beyond the rule: a chain is only as good as its awareness of upstream catalogue changes.+The free 3D lane needs no account and no key. Three choices keep it sustainable:-**Reasoning models need an explicit flag.** The Nemotron rung is a reasoning family, so it sends `enable_thinking: false` to keep the answer in `content` rather than in a reasoning field the caller does not read. A chain that treats every provider as interchangeable will produce empty answers on exactly the rungs that are working.+1. **Scale to zero where the traffic is spiky**, and keep standing GPU-hours only where a warm instance makes a visible difference.+2. **Self-host the lanes we can**, so each generation costs only its own compute.+3. **Check before you generate.** Two of our free endpoints exist to save GPU work: a physics-readiness grade that tells a caller whether an asset is usable as a rigid body before they build on it, and a vision tool that lets an agent look at what it generated, as rendered frames, and decide whether to iterate. A free check gets run on every asset, and a caller who can evaluate a result iterates deliberately instead of regenerating from scratch.-**Never let the chain be empty.** Two rungs in ours are keyless on purpose, so there is always something at the bottom. A failover chain whose last rung requires a key that might be unset is a chain with a hole in it.+## The programmes behind the fleet-## What "free and keyless" actually costs+three.ws takes part in eight partner programmes, and two of them sit directly under this post:-The free 3D lane needs no account, no key, and no payment. That is a product decision with an infrastructure bill behind it, and the bill is manageable for three specific reasons:+- **NVIDIA Inception.** We are a member (accepted July 2026). Every 3D generation lane runs on NVIDIA silicon: text to 3D, photo to avatar, auto-rigging, and motion, plus the hosted NIM lane behind chat, vision, embeddings, safety, and speech. Membership is how we plan to scale past free-tier limits while keeping the free-first design.+- **Google Cloud.** three.ws is a member of Google Cloud for Web3 Startups, which backs our compute and Vertex AI usage. The whole fleet above runs on Cloud Run GPU services, and the Vertex Gemini rung anchors the text chain from our own cloud budget.-1. **Scale to zero where the traffic is spiky**, and pay standing GPU-hours only where a cold load would be visibly bad.-2. **Self-host the lanes we can**, so the marginal generation costs compute rather than vendor margin.-3. **Grade before you spend.** Two of our free endpoints exist to *avoid* GPU work: a physics-readiness grade that tells a caller whether an asset is usable before they invest in it, and a vision tool that lets an agent look at what it generated and decide whether to iterate. A check that costs money is a check nobody runs, and a caller who cannot evaluate a result will re-generate blindly, which costs everyone more.+The other six programmes are OpenAI (Select Partner), IBM (Business Partner), Alibaba Cloud, AWS, HackerNoon (media), and Quicknode (infrastructure). Each is a programme designation, and nothing here is a statement by any of those companies.## Try it, and check the claims@@ -83,6 +102,6 @@ curl -s -X POST https://three.ws/api/3d/studio \curl "https://three.ws/api/sim-readiness?src=<glb url>"```-The workers (workers/), the routing (api/_lib/forge-tiers.js), the keep-warm cron (api/cron/gpu-keepwarm.js), and the failover chains (api/_lib/llm.js) are all in the open repository, nirholas/three.ws on GitHub, and `GET https://three.ws/api/version` returns the exact commit production is running, so anything above can be checked against the code that serves it.+The workers (workers/), the routing and cold-start budgets (api/_lib/forge-tiers.js), the keep-warm cron (api/cron/gpu-keepwarm.js), the model audit (api/cron/free-model-audit.js), and the failover chains (api/_lib/llm.js) are all in the open repository, nirholas/three.ws on GitHub, and `GET https://three.ws/api/version` returns the exact commit production is running, so anything above can be checked against the code that serves it.-If you run generation lanes on granted GPU capacity, I would like to compare notes on two things: how you decide which lanes deserve a warm floor, and whether anyone has found a better answer to cold weight loads than "pay for a floor and be honest about the wait".+If you run generation lanes on granted GPU capacity, I would love to compare notes on two things: how you decide which lanes earn a warm floor, and what has worked best for you on cold weight loads. And for the NVIDIA folks reading: we would be glad to hear whether a weight-streaming pattern or a recommended NIM container layout fits Cloud Run's FUSE-mounted volumes best.diff --git a/docs/openai-community-physical-world-post.md b/docs/openai-community-physical-world-post.mdindex bc41a5470..151828e39 100644--- a/docs/openai-community-physical-world-post.md+++ b/docs/openai-community-physical-world-post.md@@ -4,45 +4,57 @@ 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 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."+description: "A long technical follow-up on the three.ws 3D Studio connector: the fourteen keyless MCP tools, the surfaces we built on top of them, the 72-server MCP fleet behind them, the partner programmes that power it, and the design principles we use for tools that spend money and touch physical objects."status: draft, not yet posted---# From a 3D connector to a physical-world API: what we shipped after the ChatGPT 3D Studio app-_Forum post for the [OpenAI Developer Community](https://community.openai.com), posted from the nichxbt account. Category: API (Apps SDK / Actions). First person, technical, no marketing voice. Every URL in this post is live, and every endpoint marked free is keyless: you can paste the curl commands into a terminal right now and get a real answer. three.ws is a Select Partner in the OpenAI Partner Network; the usual caveat applies, it is not an OpenAI product and is not endorsed by OpenAI beyond that designation._+_Forum post for the [OpenAI Developer Community](https://community.openai.com), posted from the nichxbt account. Category: API (Apps SDK / Actions). First person, technical, no marketing voice. Every URL in this post is live, and every endpoint marked free is keyless: you can paste the curl commands into a terminal right now and get a real answer. three.ws is an OpenAI Select Partner in the OpenAI Partner Network: an independent member at the Select tier, not an OpenAI product, and not endorsed by OpenAI beyond the partner designation._----Some months ago I wrote up how we shipped [three.ws](https://three.ws) 3D Studio into ChatGPT twice: once as an Apps SDK connector over MCP, and once as a custom GPT over Actions. That post was about getting a minute-long GPU job to survive a 45 second Action timeout and render inline in a chat.+Hi everyone. Some months ago I wrote up how we brought [three.ws](https://three.ws) 3D Studio into ChatGPT twice: once as an Apps SDK connector over MCP, and once as a custom GPT over Actions. If you missed it, the short version is that you can type "a small ceramic robot figurine" into ChatGPT and a minute later you are turning a real, textured 3D model around in the conversation, then placing it on your desk in AR.-This is the follow-up, and it is a different kind of post. The interesting problems stopped being about latency. Once an assistant can call a tool that produces a real 3D asset, the next questions are much harder to design around:+A lot of you tried it, asked good questions, and sent us ideas. Thank you. This post is the follow-up, and it is written for two kinds of reader at once.-- 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 degraded rather than broken?-- And once you have fifty tool servers, how does anything discover the right one?+If you are new to 3D or to MCP, the first few sections explain what we built in plain terms: what each tool does, why it exists, and how to try it with one copy-paste. If you build tools for assistants yourself, the middle and end of the post go deep on the design choices, the wire formats, and the open-source packages you can lift into your own work.-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).+Here is the idea that ties it together. Once an assistant can call a tool that produces a real 3D asset, a whole set of genuinely interesting design questions opens up:-**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.+- How should a tool behave when it spends the user's money?+- How should a tool behave when it moves an object in the physical world, like a 3D printer or a front door lock?+- How does an agent work with a `.glb` file, which is built for renderers rather than language models?+- How do you tell an agent that a tool is ready to act right now, beyond telling it the server is up?+- And once you publish dozens of tool servers, how does a client find the right one?++We have shipped an answer to each of the five, and I want to write them down properly, because they generalise well beyond 3D. 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 has grown to fourteen tools and is still keyless. On top of it we added a vision tool so the model can look at its own output, a ready-made asset catalog so it can reuse before it generates, a physics grade so a simulator knows 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 physical actions are reserved for surfaces where a real person approves them, an open CC0 response shape for 3D results, and a set of health primitives that answer "can this agent act right now". Behind all of it sit 72 MCP servers in the official registry and 91 npm packages, and the partner programmes that power the stack get their own section near the end.++**If you only have two minutes**, here is the friendliest way in:++1. In ChatGPT, add the connector `https://three.ws/api/mcp-studio` with **No authentication** (or open the "three.ws 3D Studio" custom GPT if your plan does not do connectors).+2. Ask for something small and specific, like "a ceramic owl with a teal glaze". A rotatable model appears inline, usually within a minute, with a preview image while you wait.+3. Ask the assistant to "look at it and make the ears bigger". It renders the model, sees it, and calls `refine_model`, and each version keeps its own AR link so you can place every iteration on your desk and compare.++No account, no key, and no payment at any step. Everything after that is optional depth: rigging the model, giving it a personality and a voice, embedding it on your own site, or having it printed in nylon and shipped to you. The rest of this post walks through each of those, and through the design decisions that make them safe to hand to an agent.**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+2. Designing tools that spend money and move matter+3. `look_at_model`: letting the agent see its own output4. Simulation readiness: a grade a physics engine can act on5. 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+6. `home-mcp`: consent that only a real person can give+7. Spatial MCP: a 3D scene as a native tool result+8. "Can it act?" as a first-class health question+9. Where the model goes after the chat: embedding and animation+10. The fleet: 72 servers, and how a client finds the right one11. Your coding agent has a face now12. The whole surface, in tables-13. Affiliations, stated precisely+13. Our partners, and how each one shows up in this stack14. What I would like this forum's opinion on---@@ -51,7 +63,7 @@ We have shipped answers to all five, and I want to write them down properly, bec### 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. `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:+`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, so a reviewer can understand the whole surface at a glance. `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 \@@ -59,29 +71,38 @@ curl -s https://three.ws/api/mcp-studio \-d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'```-Eleven tools, as of today:+Fourteen tools, as of today, all free and keyless:| Tool | What it does ||---|---|-| `forge_free` | text to a textured GLB |+| `forge_free` | text to a textured GLB, with an optional `tier` of `draft`, `standard` (the default), or `high` || `text_to_avatar` | text to a rigged humanoid, skinned, with 52 ARKit blendshapes |-| `mesh_forge` | image or sketch to a mesh |+| `mesh_forge` | image or sketch to an art-directed 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 with its own AR link |+| `forge_avatar` | photo or prompt to a rigged, animation-ready avatar |+| `refine_model` | iterate on a previous result by describing a change; every refinement is its own version with its own AR link and lineage || `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) |+| `search_catalog` | search the ready-made library: CC0 props, rigged characters, motion clips |+| `get_catalog_item` | read one catalog entry |+| `get_item_source` | paste-ready code for an entry: an `<agent-3d>` tag pinned to a release with its integrity hash, `<model-viewer>`, three.js, or React || `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 |+The three catalog tools are the newest addition and they change the shape of a conversation in a nice way: before spending a minute of GPU time, the assistant can check whether three.ws already publishes a lamp, a chair, or a waving animation, and hand back code that works immediately. They never count against the generation quota.++The `high` tier runs on our own self-hosted Hunyuan3D GPU worker for denser geometry, and the default `standard` tier is served by whichever free engine the router picks for the prompt, typically our self-hosted TRELLIS worker. Every tier is platform-funded, so the caller stays anonymous and keyless at every level of quality.+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 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.+We also serve a second front door for the ChatGPT directory specifically, `https://three.ws/api/mcp-chatgpt`, which advertises the eight 3D tools and the model viewer. Both doors share one handler and one generation quota, and a single `SURFACES` definition in `api/_mcp-studio/dispatch.js` decides what each one advertises, so the two can never disagree.++One configuration detail is worth sharing because it makes the inline viewer work beautifully in production: the widget's `openai/widgetCSP` allowlist names exactly two origins, `https://three.ws` and the model-viewer CDN. Every off-origin GLB is re-served through our own `/api/glb` proxy and every poster image through `/api/img`, so the CSP stays tight, contains no wildcards, and every model loads in real ChatGPT exactly as it does in a local harness. If you build a widget that renders remote assets, routing them through your own origin is the pattern I would recommend.### 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 (pasting means the GPT builder holds a snapshot that silently drifts from the contract you actually serve).+Same free lane as plain REST, for people whose plan does not do connectors. OpenAPI 3.1 is served at `https://three.ws/.well-known/3d-studio-openapi.yaml` and imported by URL rather than pasted inline, which keeps the GPT on exactly the contract we serve, every time.```bashcurl -s -X POST https://three.ws/api/3d/studio \@@ -89,37 +110,39 @@ 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 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.+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 it is a lovely thing to show. The GPT shows that image as markdown while it waits. It is a small touch 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.+The poll endpoint returns `429` with a `retry_after` if the model polls too quickly, and the GPT's instructions tell it to honour that and keep the user posted on progress. The result is a calm, accurate conversation from prompt to finished model.++The Actions lane also carries an age-13-plus safety gate and store-clean responses (model URLs and job state only), and AR rides both ChatGPT surfaces through the same `arUrl` contract and device-aware launcher.----## 2. The design problem nobody warns you about: tools that are not free and not reversible+## 2. Designing tools that spend money and move matter-A 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.+A read-only tool is simple to reason about: it either returns something useful or it does not. A tool that spends money or moves matter deserves a richer design, and MCP's annotation vocabulary (`readOnlyHint`, `destructiveHint`, `openWorldHint`) is a great starting point for it. Annotations tell the client what a tool is. Server-side rules decide what the tool does.-We ended up with four rules, each learned the hard way.+We design every such tool around four rules.-**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 1: the refusal lives on the server.** A guard written into the API holds for every client, ours and everyone else's. In our smart home tools, a household member with the `guest` role cannot approve unlocking a door, and that rule is enforced by the server, so no client could ever offer the button. We write 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 2: every check runs before any charge.** Our [Knock](https://three.ws/knock) surface lets someone pay to get one message to a person they do not know. Price (anything from $0.001 to $1,000, or a free door), daily cap, message length, and block list are all evaluated **before** any payment is attempted, so every paid knock is a knock that lands. A priced door also cannot be opened without a payout address: the API checks that first too.-**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.+**Rule 3: a tool that makes a physical object gets a content gate that can 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 puts a person at that checkpoint. When an agent is the buyer, the checkpoint is code, and we built it that way from day one.-**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.+**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`, authenticated by OAuth 2.1 or paid per call over HTTP 402, 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.+We read OpenAI's review guidelines on commerce as a design spec rather than a compliance checklist, and the principle we take from them is simple: every paid call is clearly presented as paid, up front, before anything happens.----+Annotations are part of that honesty too. Our six generators carry `readOnlyHint:false`, `destructiveHint:false`, `idempotentHint:false`, and `openWorldHint:true`, because they run against external model APIs and never modify or delete anything. `check_job` is annotated as not read-only and not idempotent, because the first check that finds a job finished materializes the creation (copying the model into our storage, recording it, running the quality gate). `look_at_model` is genuinely read-only and idempotent. Accurate annotations let a client make good decisions on the user's behalf.-## 3. `look_at_model`: the agent could not see its own output+----Every text-to-3D API, ours included, historically answered with a URL to a binary file. A human clicks it. **An agent cannot.** A `.glb` is opaque to a language model, so the assistant that just spent GPU time generating an asset has no way to tell a clean mesh from a melted one. It hands over the link and hopes.+## 3. `look_at_model`: letting the agent see its own output-That is the reason agentic 3D stalls after one shot: there is no feedback signal to iterate on.+A `.glb` is a binary format built for renderers. A person opens it in a viewer and sees the model instantly. A language model needs it translated into its own modality, and once it has that, generation becomes a loop instead of a single shot.-`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.+`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. You can ask for up to six views (`front`, `three-quarter`, `side`, `back`, `top`, `bottom`; the default is three-quarter, front, side, back) at 128 to 1024 pixels. Alongside the frames it returns geometry facts (triangle count, bounds, material and texture counts, whether it is skinned) and a plain-language reading of them.Three ways in, depending on what you are:@@ -135,15 +158,15 @@ 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.+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 pairs beautifully with 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.+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 gets a precise answer about what its last edit did.---## 4. Simulation readiness: a grade a physics engine can act on-A renderer forgives almost everything. A rigid-body solver forgives nothing. The same mesh that looks perfect in a viewer can sink through the floor in MuJoCo, spin like it is hollow in Bullet, or turn out to be a metre tall when you asked for a teapot, because the generator fitted it to a unit box and nothing in the file says so.+Physics engines ask more of a mesh than renderers do. A rigid-body solver in MuJoCo or Bullet wants a closed surface, consistent winding, positive volume, and real-world units, so it can compute mass and behave the way the object would in the world. Generators often fit a model to a unit box, so knowing the intended size is part of the answer too.So we published a grade, free and keyless:@@ -167,20 +190,20 @@ Four verdicts, and the distinction between the middle two is the useful part:|---|---|---|| `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 |+| `needs_repair` | Open, non-manifold, or inconsistently wound | Close the surface first, then grade again |+| `unusable` | No triangles, or zero volume | Choose or generate another asset |-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.+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 file in another format, the other is a valid file with nothing to simulate.-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.+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 choice: keeping an assurance check free means it runs everywhere it is useful.-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.+If you are building anything where an LLM produces assets for a simulator, a game engine, or a robotics stack, please borrow this idea even if you never touch our endpoint. A machine-readable claim about physical usability is a natural next layer for the glTF ecosystem, and we would love to see it spread.----## 5. Materialize: what happens when the tool call ends in a cardboard box+## 5. Materialize: when the tool call ends in a cardboard box-[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.+[Materialize](https://three.ws/materialize) is the physical lane. Describe an object, generate it, then have it printed 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, end to end.```a forge creation a GLB you upload an agent@@ -199,21 +222,24 @@ If you are building anything where an LLM produces assets for a simulator, a gam```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.+2. **Preparation.** `POST /api/print/prepare` reconstructs the mesh as a solid, fills its holes, scales it to the chosen height, optionally hollows it with drain holes (which is what makes a large resin print affordable), and exports binary STL, 3MF, and the repaired GLB. Full-colour materials get per-vertex colour sampled from the source texture.+3. **A signed quote token**, valid 24 hours, carrying every priced parameter inside its signature, so the price an agent was quoted is the price it pays. Every line is itemized: build setup, material with the exact cubic centimetres it was computed from, finish, quantity break, shipping.+4. **Two checkouts, one pipeline.** A human pays in the browser in USDC on Solana; an agent pays over HTTP 402. Same order record, same statuses, same fulfillment.+5. **Safety screening** before production, as described above.+6. **Provenance in the box.** Every print ships with a certificate of authenticity, attested publicly on Solana, with a QR code, so the object can show which generation produced it. Creators can cap how many copies of a model will ever exist.+7. **Order tracking at every step**: `screening`, `submitted`, `printing`, `quality_check`, `shipped`, `delivered`, each appended to a timeline at `GET /api/print/orders/:id`, so the owner always knows exactly where the order is.++The live catalog (`GET /api/print/catalog`) currently offers standard resin, tough resin, SLS nylon (PA12), full-colour sandstone, a PLA draft option, and 316L stainless steel. Each material card is measured against your specific model, and the size slider's bounds come from the mesh itself: the low end is where the thinnest wall reaches the material's minimum, the high end is where the widest axis fills the print bed. A **See it at true size** button places the object on your real floor in AR at the exact height you are ordering, because the AR scale is taken from the same number the price was computed from. Steel is quote-on-request: it is priced as an estimate for an engineer to confirm, rather than through instant checkout.-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.+The design principle for tool authors: **an irreversible tool deserves 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+## 6. `home-mcp`: consent that only a real person can giveThis 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 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.+[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 covering Zigbee, Z-Wave, Matter, Thread, BLE and the long tail, around 90k stars) and speaks MCP natively through its `mcp_server` integration. We wrote no device code at all. What we add is the face: 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:@@ -224,38 +250,36 @@ claude mcp add home \-- npx -y @three-ws/home-mcp```-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.+Every call that would open the house passes through a physical-action gate, and **over stdio that gate declines by design.** The reasoning: a stdio MCP server has no user-visible surface of its own and no session in which a person can be shown a request and approve it. So physical actions like unlocking are reserved for surfaces where a real person sees a real prompt, and the local server tells the assistant clearly what it will do instead and why. The gate has one implementation, shared with [`@three-ws/home-bridge`](https://www.npmjs.com/package/@three-ws/home-bridge), so both enforce exactly the same rule.-Adjacent decisions from the same wave, since they are all the same trust question:+Adjacent decisions from the same wave, since they all answer the same trust question:-- **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.+- **Households and five roles** (`owner`, `admin`, `member`, `guest`, `viewer`), each stating in plain language, at the moment you pick it, what it can do. A member who lives there can confirm a guarded action; a guest can turn on lights and is never asked to approve unlocking anything. Scoped guests and viewers receive only the rooms they were given: the others are **removed from the payload**, not hidden in the UI, so their client only ever knows about the rooms they were invited into. 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 names the person who took it. Exactly one owner per home is a schema fact, enforced by a partial unique index.+- **A relay for houses on a home network**, 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 stays in the building. The threat model is published.+- **Voice**, hands-free, live at [/voice/home](https://three.ws/voice/home), built on silero VAD and openWakeWord running on the listener's own machine. Confirming a physical action requires an intentional utterance, so a background "yeah" picked up from the room is never treated as approval.- **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.+- **Matter, measured.** We prototyped the agent as a Matter device on matter.js and published the full measurements. It commissioned into a real Home Assistant over plain IP, with no Bluetooth or Thread, in 744 ms; Home Assistant reached the agent in 328 ms and the agent reached Home Assistant in 531 ms; it ran at 73 MB of memory and 0.03% of one CPU. Most usefully, a guarded `lock.unlock` attempted through a Matter automation was held at `needs_confirmation` and the door stayed locked until a human confirmed. The measurements are published so the next step starts from data.-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.+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 the primary interface. 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. The architecture follows from that: 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, and the native CarPlay scene is written in the tree, with Apple's entitlement request as the next step.----## 7. Spatial MCP: a 3D scene should not be a URL in a text block+## 7. Spatial MCP: a 3D scene as a native tool result-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.+Charts became first-class results in assistants because a picture of the data reads better than a link to it. 3D deserves the same treatment: a model you can turn around right in the conversation, rendered natively by the client.-[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.+[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. three.ws is the reference implementation. The validator (`validateSpatialArtifact()`, `buildSpatialArtifact()`, `lintSpatialMeta()`) and the conformance fixture corpus are published as [`@three-ws/spatial-mcp`](https://www.npmjs.com/package/@three-ws/spatial-mcp), dependency-free, and the package's own test suite runs over every fixture so the corpus and the reference validator always agree. If you would rather not write code, paste a payload into the checker on the [Spatial MCP page](https://three.ws/spatial-mcp) and read the conformance and data-minimization diagnostics directly. The live demo there renders a transformed payload beside a native three.ws artifact in the same renderer, which shows the portability in action. The shape carries no payment, wallet, or token surface at all, which keeps it easy for any client to adopt.-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.+I would genuinely love other 3D tool authors here to adopt or fork it. A shared shape is worth more to all of us than any one 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`.+## 8. "Can it act?" as a first-class health question-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 checks answer "is the process up?", and they do it well. An autonomous agent also needs a second question answered: "can it act right now, and if not, what is the one thing to fix?" Acting depends on a chain of preconditions the process itself does not see: a current model chain, provider credit, a funded wallet, a reachable RPC, a live data feed.-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.+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 ──┐@@ -265,20 +289,27 @@ 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 properties fall out of that shape, and both are the kind of thing a single health bit cannot express:++- **`exit` deliberately depends on neither the feed nor a model.** An agent that can still close a position should be reported as able to close it, whatever the state of its reasoning lane.+- **`deploy-fresh` only feeds `cognition` for an agent that actually uses a model**, so each capability depends on exactly the preconditions it really needs.++Each vital reads a real source: `armed` reads the owner's strategy settings, `solvency` asks the executor's own sizing rule whether the wallet can fund one action, `rpc` calls `getSlot` on a Solana RPC, `feed` watches the live data stream, `deploy-fresh` reads the running image's create time, and `cognition` makes a real completion through the model chain. There is an operator CLI (`npm run agent:vitals`) and an ops-gated HTTP endpoint (`GET /api/agents/vitals`).-Two neighbours from the same problem:+The engine is a framework-agnostic package with no dependencies ([`packages/agent-vitals`](https://github.com/nirholas/three.ws/tree/main/packages/agent-vitals), also on npm as [`@three-ws/agent-vitals`](https://www.npmjs.com/package/@three-ws/agent-vitals)). Nothing about it is specific to our platform, and if you run an agent fleet I think you will enjoy having it: it turns "can it act?" into a direct, explainable answer.-- [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 line of thinking:-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.+- [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: every fallback it lists has been executed for real, with the provider it protects against genuinely refusing, inside the same request path a user hits, and the proof receipts are on the live registry.+- [x402 Preflight](https://three.ws/preflight) and [`@three-ws/x402-preflight`](https://www.npmjs.com/package/@three-ws/x402-preflight): confirm that a paid seller can settle before signing 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 goes from red to green as the issue is fixed. A user's report becomes a runnable experiment automatically, which is exactly the part a machine does well. It works on any site, with or without the rest of our stack.---## 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.+A recurring question in the original thread was some version of "great, I generated a fox in ChatGPT, what can I do with it next?" The answer is the rest of the platform, and it is worth summarising because it is what turns the connector into a starting point for real projects.**Embedding.** Every generated avatar is a web component. One tag on any page:@@ -287,11 +318,11 @@ A recurring question in the original thread was some version of "great, I genera<agent-3d agent="<id>"></agent-3d>```-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.+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. Versioned embed releases are pinned with Subresource Integrity hashes, which is what `get_item_source` hands back.-**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, 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.+**Animation, which is what brings a body to life.** Our clip library works across rig conventions. Bone names are canonicalised across Mixamo, Unreal, VRM and VRoid, VRM 1.0, Daz/Genesis, MakeHuman, Blender `.L`/`.R`, and simple `shoulderL` rigs, then idle, walk and the rest are retargeted onto whatever came in, legs included. There is **no rig allowlist**: any humanoid drives the same pre-baked library, and a model that is not skeleton-driven (a prop, a non-humanoid) gets the default rig instead. 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 borrow.-**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.+**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 and refines as the rest arrives. [`@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:**@@ -301,26 +332,22 @@ npx @three-ws/create-agentThat 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.+**And a favourite:** [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 the page's *shape* over Portal, which is compact 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.+## 10. The fleet: 72 servers, and how a client finds the right one-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.+This is the section I most wanted to write.-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.+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. Every capability that felt independently useful became its own small, precise server, because a server is cheap to publish. That gives clients exactly the tool set they want, and it makes discovery a design problem worth solving deliberately. Here is how we approach it.-What we do about it, in the order we found it worked:+1. **One tightly scoped server per audience.** The ChatGPT-facing server is exactly the 3D tools and nothing else. The plugin guidelines reward tightly scoped apps, so one focused, coherent surface is the right shape for a directory, with the rest documented as direct MCP 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 so the auth handshake works first time in every client. That public, production OAuth 2.1 server is the gating requirement for the OpenAI plugin directory, and it is already live.+3. **Typed tool authoring, shared.** Our in-repo tool SDK ([`packages/tool-sdk`](https://github.com/nirholas/three.ws/tree/main/packages/tool-sdk)) gives us `defineTool` and `defineExec`, so annotations, schemas, and error shapes are consistent across every server we ship.+4. **Publish where clients look.** Beyond the official registry, our servers are live on PulseMCP (ingested from the registry), Glama, and the LobeHub MCP marketplace, and four Claude Code plugins ship from the repo's own marketplace.-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.+If you are about to publish your fifth MCP server, here is the question we now ask first: is this a server, or a tool namespace inside one? Answering it early keeps a fleet easy to discover.---@@ -328,15 +355,15 @@ If you are about to publish your fifth MCP server, my honest advice is to stop aNot 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.-The second half is the point:+The second half is the fun part:```bashnpx @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`).+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, reacts when a tool reports an error, 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.+An ambient face in a second pane turns out to be a wonderful progress indicator, 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.---@@ -346,11 +373,12 @@ An ambient face in a second pane turns out to be a much better progress indicato| What | Endpoint ||---|---|-| 3D Studio MCP, 11 tools | `POST https://three.ws/api/mcp-studio` |+| 3D Studio MCP, 14 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` |+| Print material catalog | `GET https://three.ws/api/print/catalog` || Live commit and revision of production | `GET https://three.ws/api/version` |**Paid or gated**, on separate servers from the free ones.@@ -361,7 +389,7 @@ An ambient face in a second pane turns out to be a much better progress indicato| 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 |+| Home control | [`@three-ws/home-mcp`](https://www.npmjs.com/package/@three-ws/home-mcp) | free, gated, physical actions on human-approved surfaces |**The footprint behind it**, from an audit dated 2026-08-25 unless noted:@@ -374,30 +402,33 @@ An ambient face in a second pane turns out to be a much better progress indicato| Specs | 31, including the CC0 Spatial MCP and simulation-readiness shapes || Test files | around 1,750 |-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.+Every generation lane has a failover chain, so each request always has a next lane ready to answer it. `GET /api/version` returns the exact commit production is running, so you can see that what is deployed is what is on GitHub.----## 13. Affiliations, stated precisely+## 13. Our partners, and how each one shows up in this stack++Several partner programmes sit underneath what this post describes, and each one connects to a specific part of it. Here they are, with each designation stated exactly:-I would rather over-disclose than let a reader assume something wrong:+- **OpenAI**: three.ws is an **OpenAI Select Partner** in the OpenAI Partner Network, an independent member at the Select tier. three.ws is not an OpenAI product and is not endorsed by OpenAI beyond the partner designation. The keyless 3D Studio connector, the custom GPT in the GPT Store, AR handoff, and the Spatial MCP shape are our builds on OpenAI's public Apps SDK and Actions platforms. The free connector is the surface we built for the ChatGPT directory, and the public OAuth 2.1 server that the OpenAI plugin directory requires is already live. Our OpenAI Cookbook example (a self-correcting 3D collectible set built with text-to-3D, function calling, and vision) is open as [PR #2874](https://github.com/openai/openai-cookbook/pull/2874).+- **IBM**: three.ws is an **IBM Business Partner**. Agents can think on IBM Granite models served through watsonx.ai, and Granite Guardian runs as a governance layer in front of autonomous actions, which is the same family of idea as the server-side refusals in section 2. Our public Granite-backed endpoints are independent developer tools built on IBM's publicly available Granite models: not IBM products, not partnership deliverables, and not endorsed by IBM.+- **Amazon Web Services**: three.ws is an **AWS Partner**. The AWS Marketplace SaaS integration is built, deployed, and conformant with the Concurrent Agreements requirements AWS introduced for new SaaS products on 2026-06-01, and the Marketplace listing is coming. It is designed as a free front door: subscribing links an AWS account to a three.ws account and issues an x402 access key for the paid lanes in section 12.+- **Google Cloud**: three.ws is a member of **Google Cloud for Web3 Startups**. Production runs on Google Cloud: one Cloud Run service serves the frontend, the route table, and every API handler, the crons run on Cloud Scheduler, the GPU model workers run on their own Cloud Run services, and Vertex AI provides the Gemini and image lanes in the model chain. Every free tool in this post is served from there.+- **NVIDIA**: three.ws is a member of **NVIDIA Inception** (since July 2026), NVIDIA's programme for startups building on accelerated computing. Membership is a startup programme, not a partnership, an investment, or an endorsement. Every 3D generation lane in section 1 runs on NVIDIA silicon: a self-hosted Cloud Run GPU fleet (L4 plus an RTX PRO 6000 Blackwell) behind text-to-3D, rigging, and motion, plus a free hosted NIM lane behind chat, vision, embeddings, safety, and speech.+- **Alibaba Cloud**: three.ws is **live on the Alibaba Cloud International Marketplace**, with a product listing, a storefront, and an editorial feature on the Alibaba Cloud Marketplace blog. Qwen models are first-class lanes in our multi-model brain router, so an agent can be pointed at a Qwen model the same way as any other.+- **HackerNoon**: our **media partner**. three.ws announcements flow automatically from our RSS feed into HackerNoon's drafts queue, and pieces that publish there carry canonical URLs back to three.ws.+- **Quicknode**: accepted into the **Quicknode Startup Program** (July 2026) with approved infrastructure credits. Quicknode's distributed RPC endpoints are a rung in our Solana RPC failover chain, adding capacity behind agent wallets, x402 settlement verification, and the `rpc` vital in section 8.-- **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.+We also publish to the Solana dApp Store, where our Android app is live, and an iOS app lives in the repo alongside it. The public map of all of this is at [three.ws/partners](https://three.ws/partners), and partnership enquiries go to [email protected].---## 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 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`, 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.+1. **Physical-action tools and MCP annotations.** `destructiveHint` covers "this deletes something". A richer vocabulary could distinguish "this spends $40" from "this unlocks a front door". Is anyone modelling that distinction in a way clients could act on? I would love to converge on something shared.+2. **Consent in stdio MCP servers.** Our answer was to reserve physical actions for surfaces where a person approves them. Is there a pattern where a stdio server can obtain provable human consent directly?+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. Is there appetite for a shared convention so every builder gets it for free?+4. **Binary results.** `look_at_model` was the highest-leverage tool we shipped this year. What other formats would your agent benefit from seeing in its own modality?+5. **Fleet discovery.** If you publish more than a handful of MCP servers, how are you handling namespacing and discovery? The approach above works well for us, and I would love to compare notes.-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).+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), the docs index is at [three.ws/docs](https://three.ws/docs), and the free connector is one `tools/list` away whenever you want to try it.diff --git a/docs/publishing-program-2026-09.md b/docs/publishing-program-2026-09.mdindex 7702a9881..48b0f849d 100644--- a/docs/publishing-program-2026-09.md+++ b/docs/publishing-program-2026-09.md@@ -24,7 +24,7 @@ Two rules that apply to every entry, because both have burned publishing program| 1 | OpenAI Developer Community | [openai-community-physical-world-post.md](./openai-community-physical-world-post.md) | The follow-up to the 3D Studio connector: tools that spend money or move matter, the vision loop, the 72-server fleet problem | ~5,650 words | Owner approval || 2 | AWS Builder Center | [aws-builder-center-agent-commerce-spine.md](./aws-builder-center-agent-commerce-spine.md) | The authorization spine for autonomous commerce: Concurrent Agreements, budgets instead of credentials, preflight, receipts, physical fulfillment | ~4,000 words | Owner approval || 3 | IBM Community (Three.ws User Group) | [ibm-community-governed-agents-post.md](./ibm-community-governed-agents-post.md) | Granite Guardian as an action veto once agents touch homes, cars and manufacturing, plus the full watsonx.ai surface and a build-it-yourself walkthrough | ~4,900 words | Owner approval |-| 4 | CoinMarketCap Community | [coinmarketcap-article-2026-09-agent-economy.md](./coinmarketcap-article-2026-09-agent-economy.md) | What an agent can actually buy now, with the on-chain and payment infrastructure behind it and the honest numbers | ~4,150 words | Owner approval, plus the other-coin commit gate |+| 4 | CoinMarketCap Community | [coinmarketcap-article-2026-09-agent-economy.md](./coinmarketcap-article-2026-09-agent-economy.md) | What an agent can actually buy now, with the on-chain and payment infrastructure behind it and the honest numbers | ~7,850 words | Owner approval, plus the other-coin commit gate || 5 | Home Assistant Community | [home-assistant-community-post.md](./home-assistant-community-post.md) | A HACS integration that dials out, an MCP server whose lock tools refuse over stdio, household roles enforced server-side | ~1,750 words | Owner approval || 6 | three.js Forum | [threejs-forum-post.md](./threejs-forum-post.md) | Five open-sourced pieces: retargeting with no rig allowlist, progressive GLB, glTF diffing, physics grade, terminal renderer | ~1,470 words | Owner approval || 7 | NVIDIA Developer Forums | [nvidia-forum-gpu-fleet-post.md](./nvidia-forum-gpu-fleet-post.md) | The production GPU fleet: cold weight loads, min-instances as a quota decision, keep-warm crons, chains with no empty rung | ~1,480 words | Owner approval |@@ -34,6 +34,19 @@ Two rules that apply to every entry, because both have burned publishing program| 11 | NVIDIA Developer Forums | [nvidia-forum-browser-digital-human.md](./nvidia-forum-browser-digital-human.md) | Audio2Face-3D streamed onto a rig the visitor generated ninety seconds ago | ~1,570 words | [Posted 2026-09-22](https://forums.developer.nvidia.com/t/a-digital-human-in-a-browser-tab-streaming-audio2face-3d-onto-whatever-rig-the-visitor-brought/383953) || 12 | NVIDIA Developer Forums | [nvidia-forum-model-retirement-post.md](./nvidia-forum-model-retirement-post.md) | Both models our live posts featured were retired within weeks: why a 410 is invisible to a fallback chain, vector tags that survive an embedder retirement, three lifecycle asks of NVIDIA | ~2,300 words | [Posted 2026-09-21](https://forums.developer.nvidia.com/t/nvidia-nim-model-retirements-what-a-410-gone-does-to-a-fallback-chain-and-how-we-survive-it-now/383950) |+## CoinMarketCap niche series, October 2026++Six long-form deep-dives (each with a friendly opening, the technical depth after it, and a partners section) for the CoinMarketCap Community blog, each on one narrow mechanism rather than the platform tour, so the account can publish a steady run of posts without repeating itself. Same CMC constraints as entry 4 (191-character title and meta, H2/H3 only, no tables). Every one references crypto projects beyond $THREE (Solana, pump.fun, USDC), so each needs the other-coin commit approval and the channel approval. Space them at least three days apart; 13, 14 and 15 build on each other and read best in that order.++| # | Draft | Angle | Length | Unblocked by |+|---|---|---|---|---|+| 13 | [coinmarketcap-article-2026-10-x402-failure-paths.md](./coinmarketcap-article-2026-10-x402-failure-paths.md) | How three.ws makes agent payments on Solana reliable and verifiable: preflight, careful retries, verify-before-settle, clear pending states, signed receipts | ~6,400 words | Owner approval, plus the other-coin commit gate |+| 14 | [coinmarketcap-article-2026-10-solana-reputation.md](./coinmarketcap-article-2026-10-solana-reputation.md) | Agent identity as a Metaplex Core asset, memo attestations anyone can re-crawl, the staking market, skill licenses and royalties, and skill royalties | ~6,500 words | Owner approval, plus the other-coin commit gate |+| 15 | [coinmarketcap-article-2026-10-copy-trading.md](./coinmarketcap-article-2026-10-copy-trading.md) | Copy trading where the track record is the product: losses kept, self-dealing excluded, alpha-drip delays the reveal and never the record | ~7,050 words | Owner approval, plus the other-coin commit gate |+| 16 | [coinmarketcap-article-2026-10-sniper-oracle.md](./coinmarketcap-article-2026-10-sniper-oracle.md) | The sniper fleet trading from its own wallets, the Oracle model published with its weights, and health checks that confirm an agent can act | ~7,250 words | Owner approval, plus the other-coin commit gate |+| 17 | [coinmarketcap-article-2026-10-radar-strategy-lab.md](./coinmarketcap-article-2026-10-radar-strategy-lab.md) | Coin radar, fade radar, strategies as data, and backtests built on real launch history | ~6,200 words | Owner approval, plus the other-coin commit gate |+| 18 | [coinmarketcap-article-2026-10-vanity-mints.md](./coinmarketcap-article-2026-10-vanity-mints.md) | Why every launch mint starts with 3ws: the WebAssembly grinder, the exact Base58 odds, where the secret key lives, and how launch records confirm it | ~5,700 words | Owner approval, plus the other-coin commit gate |+## Short-form entriesAll in [short-form-venue-kit-2026-09.md](./short-form-venue-kit-2026-09.md), paste-ready with each venue's constraints applied:diff --git a/docs/short-form-venue-kit-2026-09.md b/docs/short-form-venue-kit-2026-09.mdindex 8da79d5c2..ba56ccef2 100644--- a/docs/short-form-venue-kit-2026-09.md+++ b/docs/short-form-venue-kit-2026-09.md@@ -8,7 +8,7 @@ status: drafts, owner approval required before posting (external-channel gate inThe long-form drafts live one per file (see [publishing-program-2026-09.md](./publishing-program-2026-09.md) for the full matrix). This file holds the venues where the unit of publication is a paragraph, a title, or a first comment.-**Rules that apply to every entry here.** Post as a participant, not as a brand voice: each of these communities punishes marketing register and rewards a specific technical claim with a link that backs it. Never post the same text to two subreddits. Answer replies yourself, in your own words. If a claim is not checkable in a live endpoint or the repository, cut it.+**Rules that apply to every entry here.** Post as a participant, not as a brand voice: each of these communities rewards a specific technical claim with a link that backs it. Keep every line positive and confident: describe what the work does and the design principle behind it. Never post the same text to two subreddits. Answer replies yourself, in your own words. If a claim is not checkable in a live endpoint or the repository, cut it. Where a venue welcomes it, mention the partner programmes using the exact designations in [partners.md](./partners.md), never as an endorsement.---@@ -31,17 +31,19 @@ https://three.ws/docs/sim-readiness**First comment (post immediately after submitting)**-> A renderer forgives almost everything. A rigid-body solver forgives nothing. The same mesh that looks perfect in a viewer can sink through the floor in MuJoCo, spin like it is hollow, or turn out to be a metre tall because the generator fitted it to a unit box. Nothing in the file says so, so every robotics, game-physics and world-model pipeline rediscovers the same defects by hand, one asset at a time.+> A physics engine asks a stricter question than a renderer: is the surface closed, is the winding consistent, is the volume positive, and are the dimensions real-world metres? A glTF file has no field for that, so robotics, game-physics and world-model pipelines each answer it with their own checks.>-> This is a mechanical answer to the question a physics engine actually asks: can I use this as a rigid body right now, and if not, what exactly is wrong. Four verdicts. `simulation_ready` is the only one that licenses trusting the reported mass. `needs_scale` means the geometry is sound and only the units are missing. `needs_repair` means the surface is open, non-manifold, or inconsistently wound, so mass properties are reported but unreliable. `unusable` means no triangles or zero volume. A fifth value, `unreadable`, is for bytes that are not glTF at all, deliberately distinct from a valid file with nothing to simulate.+> This is a shared, mechanical answer to the question a physics engine actually asks: can I use this as a rigid body right now, and if not, exactly what does it need. Four verdicts. `simulation_ready` is the only one that licenses trusting the reported mass. `needs_scale` means the geometry is sound and only the units are missing. `needs_repair` means the surface is open, non-manifold, or inconsistently wound, so mass properties are reported as provisional. `unusable` means there is nothing to simulate (no triangles or zero volume). A fifth value, `unreadable`, is for bytes that are not glTF at all, deliberately distinct from a valid file with nothing to simulate.>-> Free and keyless, because a check that costs money is a check nobody runs:+> Free and keyless, so it can run on every asset:>> curl "https://three.ws/api/sim-readiness?src=https://three.ws/avatars/cesium-man.glb">-> The spec is CC0 and the grader is a pure function you can vendor. I would rather this became something other people implement than something people call. Source is Apache-2.0 at github.com/nirholas/three.ws. Context: I build a text-to-3D platform, and we needed this badly enough to write it, then realised nobody should have to write it twice.+> That one comes back `simulation_ready`: 4,672 triangles, 1.51 m tall, about 0.054 cubic metres, with the centroid and a unit-density inertia tensor in the same response. Results are content-addressed by SHA-256, so identical bytes always get an identical verdict, and there is a free MCP tool (`grade_sim_readiness`) for agents that want to grade before they spend.>-> The part I would most like criticism on: the boundary between `needs_repair` and `unusable`, and whether "real-world extents" is a defensible heuristic or whether it should be a warning rather than a verdict change.+> The spec is CC0 and the grader is a pure function you can vendor. The outcome I am hoping for is other people implementing it. Source is Apache-2.0 at github.com/nirholas/three.ws. Context: I build a text-to-3D platform, we built this for our own pipeline, and we published it so nobody has to write it twice.+>+> Two design choices I would love sharp eyes on: the boundary between `needs_repair` and `unusable`, and whether "real-world extents" works best as part of the verdict or as a warning alongside it.**Alternate submission, if the readiness one has already run:** `Show HN: A live 3D avatar in your terminal, as your coding agent's face` pointing at the `@three-ws/tty-avatar` README.@@ -58,13 +60,13 @@ https://three.ws/docs/sim-readinessMaterialize by three.ws```-**Tagline (57 characters)**+**Tagline (58 characters)**```Describe an object, get it printed and posted to your door```-**Description (254 characters)**+**Description (259 characters)**```Type a description, three.ws generates the 3D model, and Materialize prints it in resin, nylon, colour sandstone or steel and ships it. Free printability report before any price. Every step is also an API, so an AI agent can order a physical object by itself.@@ -78,17 +80,19 @@ Type a description, three.ws generates the 3D model, and Materialize prints it i>> The loop: describe something, we generate it, and then it gets manufactured and posted to you. What I care about most is the order the steps happen in.>-> **The analysis is free and comes first.** Before any price, you get a printability report: whether the mesh is a closed solid, how many separate bodies it has, where the holes are, the thinnest wall, the exact volume, and a 0 to 100 score with named deductions written for a person rather than a slicer. Free because a check that costs money is a check nobody runs.+> **The analysis is free and comes first.** Before any price, you get a printability report: whether the mesh is a closed solid, how many separate bodies it has, where the holes are, the thinnest wall, the exact volume, and a 0 to 100 score with named deductions written for a person rather than a slicer. Free, so every model gets checked before anyone spends a cent.>> **The quote is signed and lasts 24 hours,** so the price you were shown is the price you pay.>> **Every print ships with proof it is the one you ordered:** a certificate of authenticity with a QR code in the box, and creators can cap how many copies of a model will ever exist.>-> **It refuses things.** No weapons, no functional key duplicates, no third-party brand marks, screened before production. A print bureau has a human at that checkpoint. We have an API where the buyer might be a machine, so the checkpoint has to be code.+> **Every order is screened before production.** Weapons, functional key duplicates, and third-party brand marks are filtered out in code. A print bureau puts a person at that checkpoint; our buyer might be an AI agent, so the checkpoint lives in the API itself.+>+> That is the part I am most excited about: an AI agent can run the whole loop, quote and order included, end to end, so an agent can turn an idea into a physical object it pays for itself.>-> That last part is the unusual bit: an AI agent can run the whole loop, quote and order included, with no human in it. As far as I know this is the first API where an agent can pay for manufacturing.+> The 3D models come from open model families running on our own NVIDIA GPU fleet. three.ws is an NVIDIA Inception member and an OpenAI Select Partner, and our free 3D Studio connector brings the same generation tools into ChatGPT.>-> Free to try the generation half with no account: three.ws/forge. Everything is Apache-2.0. Happy to answer anything, including what it costs and what it cannot print.+> Free to try the generation half with no account: three.ws/forge. Everything is Apache-2.0. Happy to answer anything, including pricing per material and how the printability score is calculated.---@@ -102,51 +106,51 @@ Five subreddits, five different posts. Never cross-post the same body.**Body:**-> Most HA installs cannot be reached from the internet: no forwarded port, no public address. That is the default install, not an edge case. So this integration works the other way around: the house dials out over a single outgoing WebSocket and the service never dials the house. Nothing listens on your network, no port forwarding, no tunnel daemon, and the service never receives an HA token (the integration mints its own credential locally and it never leaves the house).+> Most HA installs live on a home network with no forwarded port and no public address, so I designed for exactly that. This integration works the other way around: the house dials out over a single outgoing WebSocket and the service never dials the house. Nothing listens on your network, no port forwarding, no tunnel daemon, and the service never receives an HA token (the integration mints its own credential locally and it never leaves the house).>> What it connects to is a 3D agent that stands in a live model of your home and talks to you, plus an MCP server so Claude, Cursor or your own assistant can read and drive the house.>-> The part I would like this sub to pull apart is locks. Every call that would open the house passes through one physical-action gate, and over stdio that gate **refuses outright**. My reasoning: a local stdio MCP server has no user-visible surface, no session, and no way to prove a human saw the request and approved it, so any "confirm?" it prints is a string the model can answer itself. Household roles are enforced server-side too: a guest can turn on lights and can never approve unlocking anything, and a scoped guest's other rooms are removed from the payload rather than hidden in the UI.+> The part I am proudest of is locks. Every call that would open the house passes through one physical-action gate that resolves the real entities and service each call performs, and over stdio, door-opening stays on surfaces where a person can see and approve it (owners can grant one specific door to their own assistant explicitly). Household roles are enforced server-side too: five roles from owner to wall display, guests can turn on lights while approving an unlock stays with residents, and a scoped guest's other rooms are removed from the payload rather than hidden in the UI. Spoken confirmation accepts one deliberate word, "confirm", so conversation elsewhere in the room cannot stand in for it.>-> Also: we evaluated exposing the agent as a Matter device, measured it, and decided against it for now, and published why.+> Also: we prototyped the agent as a Matter device with matter.js (it commissioned into a real HA in 744 ms) and published the full write-up with measurements.>> Repo: github.com/nirholas/three-ws-home-assistant (HACS custom repository). Docs and the relay threat model: three.ws/docs/smart-home. Apache-2.0.>-> Is the stdio refusal right, or is it paternalistic? That is a genuine question and I have not settled it.+> I would love this sub's take on the stdio design: approval where a person can see it, plus explicit per-door allowances for owners who want them. How would you shape it for your house?### r/threejs-**Title:** `Five things we open-sourced after animating characters nobody on our team modelled (retargeting with no rig allowlist, progressive GLB, glTF diffing, a physics grade, a terminal renderer)`+**Title:** `Five open-source pieces for animating any 3D character, whatever rig it arrives with (retargeting with no rig allowlist, progressive GLB, glTF diffing, a physics grade, a terminal renderer)`-**Body:** short pointer to the [three.js forum post](./threejs-forum-post.md), with the retargeting section quoted in full and a request for rig conventions we have not mapped.+**Body:** short pointer to the [three.js forum post](./threejs-forum-post.md), with the retargeting section quoted in full and an invitation to share rig conventions we can add to the mapping.### r/LocalLLaMA-**Title:** `Every text-to-3D API answers with a URL to a binary the model cannot read. We fixed the loop by rendering results back into the model's own modality.`+**Title:** `We let our text-to-3D agent look at what it made: rendering each result back into the model's own modality turns one-shot generation into a generate, judge, refine loop.`**Body:**-> This is the smallest change we made this year and the one that changed the most.+> This is the smallest change we made this year and the one that unlocked the most.>-> A `.glb` is opaque to a language model. So an agent that just spent GPU time generating an asset cannot tell a clean mesh from a melted one; it hands the link to a human and hopes. No error signal means no loop, which is why agentic 3D has been one-shot since it existed.+> A `.glb` is a compact binary of vertices, materials, and bones, and a language model reads text and images. So we show the model its own output as images: render the result from several angles (up to six views, 128 to 1024 px) and return the frames as MCP image content blocks. A multimodal model looks at what it made, judges it, refines it, and looks again. Alongside the frames we return geometry facts and a plain-language reading of them.>-> The fix: render the result from several angles and return the frames as MCP image content blocks, so a multimodal model looks at what it made. Then it can judge it, refine it, and look again. Alongside the frames we return geometry facts and a plain-language reading of them.+> Pair it with `refine_model` (describe a change in words, get a new version with a branchable lineage) and the whole generate, look, judge, refine cycle runs inside any MCP client. The 3D side is open models (TRELLIS, Hunyuan3D, TripoSG) on our own NVIDIA L4 fleet.>-> The generalisation is not about 3D at all: **any tool that hands an agent a binary needs a companion that renders it into the agent's own modality.** PDFs, spreadsheets, audio, CAD, compiled artifacts. If your agent cannot perceive its own output, it is guessing.+> The generalisation is not about 3D at all: **any tool that hands an agent a binary benefits from a companion that renders it into the agent's own modality.** PDFs, spreadsheets, audio, CAD, compiled artifacts. Give your agent a way to perceive its own output and it starts iterating.>-> Free and keyless if you want to try it against your own stack: `POST https://three.ws/api/3d/look`, or the tool `look_at_model` on `https://three.ws/api/mcp-studio`. Everything Apache-2.0.+> Free and keyless if you want to try it against your own stack: `POST https://three.ws/api/3d/look`, the npm package `@three-ws/see`, or the tool `look_at_model` on `https://three.ws/api/mcp-studio`. Everything Apache-2.0.### r/3Dprinting**Title:** `We built a free printability report API (closed solid, separate bodies, thinnest wall, exact volume, 0-100 score with named deductions) and made it the step before any price is quoted`-**Body:** the analysis-first argument, the four things it measures, an honest note that the printing lane behind it is a paid service, and an invitation to tell us which deductions are wrong. Lead with the free endpoint; the sub is allergic to advertising and fine with tools.+**Body:** the analysis-first design, the four things it measures, a clear note that the printing lane behind it is a paid service, and an invitation to suggest how the deductions could be sharper. Lead with the free endpoint; the sub values useful tools.### r/robotics-**Title:** `A generated mesh that renders perfectly can be unusable as a rigid body, and the file never says so. Free grade plus a CC0 spec.`+**Title:** `A free physics-readiness grade for generated meshes (closed surface, consistent winding, positive volume, real-world scale), plus a CC0 spec you can vendor`-**Body:** the four verdicts, the `needs_scale` versus `needs_repair` distinction, the content-addressed caching, the request for adversarial review from people who have shipped assets into MuJoCo or Isaac in anger.+**Body:** the four verdicts, the `needs_scale` versus `needs_repair` distinction, the content-addressed caching, the free `grade_sim_readiness` MCP tool, and an open invitation for review from people who ship assets into MuJoCo or Isaac.---@@ -163,16 +167,16 @@ The quarter our AI agents left the browser tab**Opening (first 210 characters are the preview, make them count)**-> For most of this year our agents lived in a browser tab, and the worst thing a wrong decision could produce was a bad sentence. This quarter they got a house, a car, and a factory, and that changed the engineering.+> For most of this year our agents lived in a browser tab, where every decision ended in a sentence. This quarter they got a house, a car, and a factory, and the engineering grew to match.-**Structure:** the blast-radius argument; the three capabilities (home, car, manufacturing); the governance layer that became load-bearing; the operating principle that a refusal must live on the server and not in a prompt; the honest partner and listing status list; and a close on what it takes to make an agent economy that is not a demo. Keep it to 900 words, no code blocks, one link at the end.+**Structure:** why real-world reach raises the engineering bar; the three capabilities (home, car, manufacturing); the governance layer that makes them trustworthy (household roles, spoken confirmation, screened print orders); the operating principle that a guard lives on the server, in code; the partner programmes, each stated with its exact designation from [partners.md](./partners.md) (OpenAI Select Partner, IBM Business Partner, NVIDIA Inception member, member of Google Cloud for Web3 Startups, live on the Alibaba Cloud International Marketplace, AWS Partner, HackerNoon media partner, Quicknode Startup Program) and tied to what each one powers; and a close on what it takes to build an agent economy that runs in production. Keep it to 900 words, no code blocks, one link at the end (three.ws/partners works well).---## 5. Alibaba Cloud developer community-**Venue:** the Alibaba Cloud developer community, following our existing marketplace listing and the editorial feature already published on the marketplace blog.-**Angle:** the model router. Qwen models are first-class lanes in a multi-provider brain router that any agent can be pointed at, reached through DashScope alongside the other providers, and there is a published MCP server (`@three-ws/alibaba-cloud-mcp`) exposing Qwen chat and embeddings to any MCP client.+**Venue:** the Alibaba Cloud developer community, following our live Alibaba Cloud International Marketplace listing and storefront, and the editorial feature Alibaba Cloud Marketplace published on its blog.+**Angle:** the model router. Qwen models are first-class lanes in a multi-provider brain router (`/api/brain/chat`) that any agent can be pointed at, reached through DashScope alongside the other providers, and there is a published, community-built MCP server (`@three-ws/alibaba-cloud-mcp`, registry name `io.github.nirholas/alibaba-cloud`) exposing Qwen chat, embeddings, and model discovery on your own DashScope account to any MCP client.**Working title**@@ -180,7 +184,7 @@ The quarter our AI agents left the browser tabAdding Qwen as a first-class lane in a multi-provider agent brain, and what a router owes each provider```-**The one non-obvious point to build the piece around:** a router that treats providers as interchangeable produces empty answers on the rungs that are working, because reasoning families, tool-call shapes, and streaming conventions differ. The router's job is not to hide the provider, it is to normalise the parts that must be uniform and to report the model that actually answered, so callers can tell.+**The one non-obvious point to build the piece around:** a great router respects each provider's conventions. Reasoning families, tool-call shapes, and streaming conventions differ, so the router normalises the parts that must be uniform (for Qwen3 that includes turning reasoning mode off when a caller wants the answer in `content`) and reports the model that actually answered, so every caller knows exactly which lane served it.---@@ -197,14 +201,14 @@ Discussion: is there appetite for a machine-readable "can this be simulated" cla**Body**-> Context, briefly: we run a text-to-3D service and every downstream consumer of our output (physics engines, game engines, robotics stacks) rediscovers the same defects by hand. A glTF file carries no claim about whether it can be used as a rigid body, so the checks get re-implemented per pipeline, inconsistently.+> Context, briefly: we run a text-to-3D service, and our output flows into physics engines, game engines, and robotics stacks. Each of them asks whether an asset can be used as a rigid body, and today each pipeline answers that with its own checks. A shared, machine-readable claim could let them all answer it the same way.>-> We wrote and published one (CC0 spec, free endpoint, pure-function grader) covering four verdicts: closed surface with consistent winding and positive volume and plausible real-world extents, versus geometry that is sound but unit-scaled, versus an open or non-manifold surface whose mass properties are unreliable, versus nothing to simulate at all.+> We wrote and published one (CC0 spec, free endpoint, pure-function grader) covering four verdicts: closed surface with consistent winding and positive volume and plausible real-world extents, versus geometry that is sound but unit-scaled, versus an open or non-manifold surface whose mass properties are provisional, versus nothing to simulate at all.>-> I am not proposing an extension here, and I would like to understand the shape of the problem first:+> Before proposing anything formal, I would love to understand how the community sees the shape of it:>> 1. Is this a file-level claim, a validator concern, or purely an application concern?> 2. If it belongs anywhere in the ecosystem, is it an extension, a validator rule set, or a convention?> 3. Is "plausible real-world extents" defensible as part of a verdict, or should unit ambiguity only ever be a warning?>-> Happy for the answer to be "this is an application concern, keep it out of the format". That is useful too.+> Every answer is useful here, including "this is an application concern, keep it out of the format". Thank you in advance for any perspective.diff --git a/docs/threejs-forum-post.md b/docs/threejs-forum-post.mdindex 7fd253546..27db54a5a 100644--- a/docs/threejs-forum-post.md+++ b/docs/threejs-forum-post.md@@ -6,69 +6,115 @@ tags: [three.js, gltf, glb, animation, retargeting, webgl]status: draft, owner approval required before posting (external-channel gate in CLAUDE.md)----# Five things we had to build to animate 3D characters nobody on our team modelled+# Five open-source pieces for animating any 3D character, whatever rig it arrives with_Post for the [three.js forum](https://discourse.threejs.org), category Resources._-I work on [three.ws](https://three.ws), a browser-native platform where you type a sentence and get a rigged, animated 3D character you can embed anywhere. Apache-2.0, source at [github.com/nirholas/three.ws](https://github.com/nirholas/three.ws).+Hi everyone! I work on [three.ws](https://three.ws), a browser-native platform built on three.js. You type a sentence, and you get a rigged, animated 3D character you can drop into any web page. It is Apache-2.0, and the source is at [github.com/nirholas/three.ws](https://github.com/nirholas/three.ws).-The constraint that shaped everything: **we never see the model before it arrives.** It might come from our own generation lane, from Mixamo, from VRoid, from Daz, from a Blender export somebody made in 2019, or from a user's photo processed into a mesh ninety seconds ago. The rig is not ours and we do not get to pick the conventions.+The fun part of building it has been this: **every character is a surprise.** It might come from our own generation lane, from Mixamo, from VRoid, from Daz, from a Blender export somebody made years ago, or from a user's photo turned into a mesh a minute and a half earlier. Whatever skeleton it brings, it should walk, wave, and talk the moment it loads.-Five pieces fell out of that, each published on its own so you can use them without the rest of the platform. All of them are things I looked for first and could not find.+Making that work produced five small, focused tools. We published each one on its own so you can use any of them in your own three.js project without the rest of the platform. Here they are, from the one I use every day to the one I would most love your review on.-## 1. Retargeting with no rig allowlist+## The five, at a glance++| Piece | What it does for you |+|---|---|+| `@three-ws/retarget` | Plays any humanoid clip on any humanoid rig, with no list of supported rigs |+| `@three-ws/avatar-stream` | Shows a correct, skinned avatar early over plain HTTP, then refines it |+| `@three-ws/glb-diff` | Tells you what actually changed between two GLBs |+| Sim-readiness grade | A free check of whether a GLB can be used as a rigid body, with a CC0 spec |+| `@three-ws/tty-3d` | Renders a skinned, animated GLB in a terminal, no GPU needed |++## 1. Retargeting that welcomes every rig**Package: `@three-ws/retarget`**-The usual approach to "animate any humanoid" is a curated list of supported rigs. It works until the eleventh rig, and every asset marketplace produces new ones faster than you can add them.+Rather than keeping a curated list of supported rigs, we canonicalise bone names first, then retarget onto the canonical set. The mapping understands Mixamo (`mixamorig:LeftArm`), Avaturn, VRM 0.x and VRoid (`J_Bip_L_UpperArm`), VRM 1.0, Daz/Genesis, MakeHuman, the Unreal mannequin, HumanIK/Maya, Blender `.L`/`.R` suffixes, and simple `shoulderL` style names. Adding a new convention is one mapping entry plus a test case, never a new code path.-Instead we canonicalise bone names first, then retarget onto the canonical set. The mapping covers Mixamo, Unreal, VRM and VRoid, VRM 1.0, Daz/Genesis, MakeHuman, Blender `.L`/`.R` suffixes, and the simple `shoulderL` style rigs, and adding a new convention is one mapping entry plus a test case rather than a new code path.+```bash+npm install @three-ws/retarget three+```-Two details that took us longer than they should have:+```js+import { AnimationMixer } from 'three';+import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';+import { MeshoptDecoder } from 'three/addons/libs/meshopt_decoder.module.js';+import { canonicalizeGLBBones, retargetClipToObject, parseClipJSON } from '@three-ws/retarget';-**Legs are where naive retargeting falls apart.** Arm chains forgive a lot of proportion mismatch. Hip and foot chains do not, and the failure mode is a character that walks with its feet sliding, which readers describe as "the animation is broken" rather than "the retarget is wrong".+const raw = await fetch('https://three.ws/avatars/xbot.glb').then((r) => r.arrayBuffer());+const { buffer } = canonicalizeGLBBones(raw);-**The fallback must not be a T-pose.** If a model genuinely cannot be skeleton-driven (no skin, a non-humanoid prop), we detect that and fall back to a default rig rather than rendering a bind-pose statue. A T-pose in production reads as a bug to every user, and as "unsupported" to zero of them.+const loader = new GLTFLoader();+loader.setMeshoptDecoder(MeshoptDecoder);+const gltf = await loader.parseAsync(buffer, '');++const clipJSON = await fetch('https://three.ws/animations/clips/walk.json').then((r) => r.json());+const result = retargetClipToObject(parseClipJSON(clipJSON, 'walk'), gltf.scene);++if (result.clip) new AnimationMixer(gltf.scene).clipAction(result.clip).play();+```-If you have ever hand-mapped a skeleton table, this is the package I would have wanted.+The clip URLs are real: three.ws serves its shared clip library with open CORS, so that snippet runs as-is.++Three details we invested the most in:++**Legs get first-class treatment.** Arm chains are forgiving about proportions. Hip and foot chains need care, so the retargeter corrects rest-pose skew (A-pose versus T-pose) and hip up-axis differences automatically, and scales hip motion to the target's proportions. The result is a walk with planted feet on rigs of very different heights.++**A clear coverage gate.** Every result carries `coverage`, `matched`, `total`, and `dropped`. Below 50% bone coverage the clip comes back as `null` with the full breakdown, which is a clean, honest signal that the model is not a humanoid.++**The fallback is always a living character.** When a model cannot be skeleton-driven (no skin, or a non-humanoid prop), the runtime detects it through `supportsCanonicalClips()` and falls back to a default rig, so every visitor sees a character in motion.++If you would rather not manage mixers yourself, `AnimationManager` loads a clip library from a manifest, retargets per rig, crossfades between states, and layers one-shot overlays (a wave, a jump) over a base loop (idle, walk). If you have ever hand-mapped a skeleton table, this is the package I would have wanted.## 2. Progressive GLB over plain HTTP-**Package: `@three-ws/avatar-stream`**+**Package: `@three-ws/avatar-stream`, spec `A3S` (CC0), live at three.ws/stream**++A GLB is atomic: a client needs every byte before it can draw a triangle, because an index near the end can reference a vertex near the start. `avatar-stream` reorders the asset so that **any byte prefix of the file is a complete, valid asset**, and the viewer can draw as soon as the first layer lands, then refine.-A 12 MB avatar on a phone on a train is a blank canvas for eight seconds and then, suddenly, a character. Every user reads that pause as a broken page.+The trick is a lovely property of successive edge-collapse simplification: the vertices that survive at each coarser level are a strict subset of the level below. The levels nest. Rank every vertex by the coarsest level it survives into, sort the vertex buffer by that rank, and each refinement layer only appends vertices the client does not have yet. It never rewrites bytes already sent.-`avatar-stream` packs a GLB into a layered stream so the viewer shows something structurally correct early and refines it, over ordinary HTTP with no special server. It is not a replacement for compression, it composes with it. The reason we wrote our own rather than reaching for an existing progressive format is that we needed the first frame to be *correct*, not a blob: an avatar that appears with the wrong proportions and then snaps is worse than one that appears late.+Skinning comes along for free. A simplifier emits a new index buffer over the vertex array it was given, so `JOINTS_0` and `WEIGHTS_0` are carried along untouched, and the very first coarse layer is already bound to the full skeleton. That means the first thing a visitor sees is the right character with the right proportions, already animating, rather than a placeholder.++It works over ordinary HTTP from a static host, and it composes with compression rather than replacing it. The endpoint is `GET /api/avatar-stream?src=<glb>`, the reference implementation is the package, and the container format is published as a CC0 spec so anyone can implement it.## 3. A structural diff for glTF**Package: `@three-ws/glb-diff`, live at three.ws/diff**-When a generation pipeline iterates on a mesh, "did that change anything" is asked constantly, and eyeballing two viewers side by side is a bad instrument. `glb-diff` answers structurally: node graph, meshes, primitives, materials, textures, skins, animations, and what moved between two versions.+When a pipeline iterates on a mesh, "did that change anything?" comes up constantly. `glb-diff` answers it structurally: node graph, meshes, primitives, materials, textures, skins, and animations, with git-style rename and move detection.++```bash+npx @three-ws/glb-diff before.glb after.glb --markdown+npx @three-ws/glb-diff base.glb candidate.glb --fail-on major+```++`--markdown` produces a report sized for a pull-request comment, `--json` gives the full change set, and `--fail-on <level>` exits non-zero once a change reaches the severity you choose, so it drops straight into a CI job that guards your asset folder.-It started as an internal debugging tool for our refine loop and turned out to be the thing I reach for most when a model looks subtly wrong. If you run any pipeline that mutates glTF (optimisation, retexturing, decimation), this is worth ten minutes.+It started as a debugging tool for our refine loop and quickly became the thing I reach for most whenever a model needs a closer look. If you run any pipeline that mutates glTF (optimisation, retexturing, decimation), it is worth ten minutes.## 4. A physics-readiness grade, and a CC0 spec for it-**Free endpoint: `GET https://three.ws/api/sim-readiness?src=<glb>` . Spec: `specs/SIM_READINESS.md`, CC0**--This is the one I would most like this forum to tear apart, because I think the gap is real and I do not think our answer is final.+**Free endpoint: `GET https://three.ws/api/sim-readiness?src=<glb>`. Free MCP tool: `grade_sim_readiness`. Spec: `specs/SIM_READINESS.md`, CC0**-A renderer forgives almost everything. A rigid-body solver forgives nothing. The same mesh that renders beautifully in three.js can sink through the floor in a physics engine, behave as if hollow, or turn out to be a metre tall because the generator fitted it to a unit box. **A GLB carries no claim about whether it can be simulated**, so every robotics, game-physics and world-model pipeline rediscovers the same defects by hand, one asset at a time.+This is the one I would most love this forum's review on.-The grade answers four things mechanically: closed surface, consistent winding, positive volume, and whether the extents are plausible real-world metres.+A physics engine asks a stricter question than a renderer. It needs a closed surface, consistent winding, positive volume, and dimensions in real-world metres. A GLB has no field that says whether it meets those, so the grade answers all four mechanically:```bashcurl "https://three.ws/api/sim-readiness?src=https://three.ws/avatars/cesium-man.glb"```-Four verdicts. `simulation_ready` is the only one that licenses trusting the reported mass. `needs_scale` means the geometry is sound and only the units are missing (multiply and go). `needs_repair` means open, non-manifold, or inconsistently wound, so the mass properties are reported but unreliable. `unusable` means no triangles or zero volume. There is a fifth value, `unreadable`, for bytes that are not binary glTF 2.0 at all, deliberately distinct: one is a broken file, the other is a valid file with nothing to simulate.+Cesium Man comes back `simulation_ready`: 4,672 triangles, 1.51 m tall, about 0.054 cubic metres of volume, with the centroid and an inertia tensor at unit density in the same response.-Results are content-addressed by the file's SHA-256, so the same bytes always get the same verdict.+Four verdicts. `simulation_ready` is the one that licenses trusting the reported mass. `needs_scale` means the geometry is sound and only the units need setting (multiply and go). `needs_repair` means the surface is open, non-manifold, or inconsistently wound, so the mass properties are reported as provisional. `unusable` means there is nothing to simulate (no triangles or zero volume). A fifth value, `unreadable`, is for bytes that are not binary glTF 2.0 at all, kept deliberately distinct from a valid file with nothing to simulate.-It is free and keyless on purpose: a check that costs money is a check nobody runs, and a check nobody runs prevents nothing.+Results are content-addressed by the file's SHA-256, so the same bytes always get the same verdict and caching is trivially correct. When a model is credentialed, its grade can also ride inside a signed content credential, together with the grader version that produced it, so a grade is a durable, attributable claim.-## 5. A terminal renderer, which sounds like a joke and is not+It is free and keyless on purpose: a free check is a check that runs on every asset, which is exactly where it does the most good.++## 5. A terminal renderer, which is more useful than it sounds**Packages: `@three-ws/tty-3d` (core), `@three-ws/tty-avatar` (the CLI)**@@ -76,32 +122,46 @@ It is free and keyless on purpose: a check that costs money is a check nobody runpx @three-ws/tty-avatar 81a076b6-55ff-49a2-b007-1d88e7dce2aa```-That draws a skinned, animated GLB in colour at 24fps in a plain terminal, no browser and no GPU. Three glyph modes: truecolor half-blocks (two colours per cell), braille (2x4 dots per cell for four times the vertical detail), and a plain luminance ramp when the output is piped.+That draws a skinned, animated GLB in colour at 24fps in a plain terminal. It is a software rasterizer: it decodes the glTF, evaluates the animation, blends joint matrices per vertex on the CPU, and rasterizes into a z-buffered framebuffer sized to your terminal. No GPU, no browser, no display server, so it runs identically over SSH, in CI, and inside a container. With nothing installed at all, `curl three.ws/tty` works too.++Three glyph modes: truecolor half-blocks (two colours per cell), braille (2x4 dots per cell for four times the vertical detail), and a plain luminance ramp when the output is piped.++Two reasons we love it. First, building a second renderer made the animation stack fully renderer-agnostic, which strengthened it for WebGL as well. Second, wire it to a coding agent's hooks and the avatar becomes that agent's face: thinking while it reads, nodding while it edits, shaking its head when a tool reports an error, bouncing when it finishes. An ambient posture in a second pane is a friendly progress indicator you can read without switching focus.++## Production practices we rely on++**Decode meshopt once, at the front of the pipeline.** Most of our avatars ship with `EXT_meshopt_compression`, and every browser viewer handles it beautifully. For server-side consumers (our Python workers use trimesh), we decode once at the entrance with a pinned `gltfpack`, so every downstream step reads plain geometry.++**Dispose the context between scenes.** Releasing GPU resources on unmount keeps scene-to-scene navigation smooth, even on a laptop loading its third scene in a row.-Two reasons it is not a toy. First, it forced the animation stack to be renderer-agnostic, which caught two bugs that WebGL was hiding. Second, wire it to a coding agent's hooks and the avatar becomes that agent's face: thinking while it reads, nodding while it edits, shaking when a tool fails, bouncing when it finishes. An ambient posture in a second pane is a better progress indicator than a spinner because you read it without switching focus.+**Wake heavy previews on view.** A grid of 3D previews initialised through an intersection observer only spends GPU on what is on screen. It turned our marketplace grid into a smooth scroll.-## Assorted production notes, since this forum appreciates them+**Keep the light rig in one shared module.** Ours is `@three-ws/viewer-presets` (tuned light rigs, floor reflections, bloom, and PBR presets), so every studio page inherits the same soft shadows and the same look from one place. A render-and-compare test on that module is the strongest way to keep it consistent.-**Meshopt will bite you server-side.** Most of our avatars ship with `EXT_meshopt_compression`. Anything in the pipeline that reads geometry outside a browser (our Python workers use trimesh) has to decode it first, and the failure is confusing because the file loads fine in every viewer you test with. If you run a server-side glTF pipeline, put the decode in front of everything, once, rather than per consumer.+**52 ARKit blendshapes is the interchange currency for faces.** It is what the tooling, the capture stacks, and the models converge on. We map onto it and keep each rig's conventions in one adapter, which is also how a VRM or Oculus-viseme rig lip-syncs from an ARKit-52 track.-**Release the context between scenes.** Our splat viewer held onto the GPU between scenes and the third scene load on a laptop was a slideshow. Disposing properly on unmount is table stakes advice that everyone including us learns twice.+## Who we build with-**Wake heavy previews on view, not on load.** A grid of 3D previews that all initialise on page load will jank on any machine. Intersection-observer gating turned our marketplace grid from a stutter into a scroll.+three.ws takes part in eight partner programmes, and a few of them show up directly in the pieces above:-**Soft shadows are the first thing to silently regress.** A renderer change that makes shadows hard does not throw, does not warn, and nobody notices for a week. Ours regressed across three studio pages at once. If you have a shared light rig, pin it in a test that renders and compares, not in a code review.+- **OpenAI Select Partner.** Our free 3D Studio connector puts text-to-3D, rigging, refinement, and `look_at_model` inside ChatGPT, with the models rendered interactively inline. We also publish Spatial MCP, an open CC0 response shape that makes a 3D scene a native MCP result rather than a link, with three.ws as the reference implementation.+- **NVIDIA Inception.** three.ws is an NVIDIA Inception member, and every character these tools animate is generated on NVIDIA GPUs: a self-hosted fleet of L4s plus an RTX PRO 6000 Blackwell.+- **Google Cloud.** three.ws is a member of Google Cloud for Web3 Startups. The whole platform, including `sim-readiness`, `avatar-stream`, and the diff page, is served from Cloud Run.+- **HackerNoon (Media).** Our engineering write-ups syndicate to HackerNoon's developer audience with canonical links back to three.ws.+- **Alibaba Cloud, IBM, AWS, and Quicknode** complete the eight, across cloud, models, and infrastructure.-**52 ARKit blendshapes is the interchange currency for faces.** Not because it is elegant, but because it is what the tooling, the capture stacks and the models converge on. We map onto it and let the rig-specific weirdness live in one adapter.+These are programme designations, and the views here are our own. The full map is at [three.ws/partners](https://three.ws/partners).## What is where- Retargeting: `@three-ws/retarget`-- Progressive streaming: `@three-ws/avatar-stream`+- Progressive streaming: `@three-ws/avatar-stream`, spec `specs/AVATAR_STREAM.md` (CC0), demo at three.ws/stream- Diffing: `@three-ws/glb-diff`, and the page at [three.ws/diff](https://three.ws/diff)- Physics readiness: [three.ws/docs/sim-readiness](https://three.ws/docs/sim-readiness), spec CC0- Terminal rendering: `@three-ws/tty-3d`, `@three-ws/tty-avatar`-- Viewer look and feel: `@three-ws/viewer-presets` (light rigs, floor reflections, bloom, PBR presets)+- Viewer look and feel: `@three-ws/viewer-presets`- The whole platform, if you want to see them in situ: [github.com/nirholas/three.ws](https://github.com/nirholas/three.ws)The generation side runs open model families on our own GPU fleet, and the free lane is keyless if you want to make something to test any of this against: [three.ws/forge](https://three.ws/forge).-Questions welcome, especially on 1 and 4. The retarget mapping wants more rig conventions from people who have hit ones we have not, and the readiness spec wants adversarial review from anyone who has shipped assets into a physics engine in anger.+Questions welcome, especially on 1 and 4. The retarget mapping would love more rig conventions from anyone who has met ones we have not mapped yet, and the readiness spec would benefit from review by anyone who has shipped assets into a physics engine.