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(mobile-launch): add the AWS Builder Center, IBM Community, and NVIDIA forum launch articles with their venue README
nirholas3ed8849b29a3
diff --git a/docs/aws-builder-center.md b/docs/aws-builder-center.mdindex 90aa0fe65..4fad264b3 100644--- a/docs/aws-builder-center.md+++ b/docs/aws-builder-center.md@@ -56,6 +56,7 @@ Written and reviewed in this repo, not yet submitted:|---|---|| [aws-builder-center-agent-payment-sessions.md](./aws-builder-center-agent-payment-sessions.md) | Agent Payment Sessions: giving an agent a budget instead of a private key, and enforcing it atomically in Postgres || [aws-builder-center-mcp-agents.md](./aws-builder-center-mcp-agents.md) | An MCP server whose paid tools settle per call in USDC over HTTP 402 |+| [mobile-launch/aws-builder-center-article.md](./mobile-launch/aws-builder-center-article.md) | One web product, three native apps, zero forks: the Seeker, Android, and iPhone shells, with the AWS SDK v3 storage client and the Marketplace front door |## Publishing checklistdiff --git a/docs/mobile-launch/README.md b/docs/mobile-launch/README.mdnew file mode 100644index 000000000..e523293c4--- /dev/null+++ b/docs/mobile-launch/README.md@@ -0,0 +1,24 @@+# Mobile launch articles++Five long-form articles announcing three.ws as three native apps (Solana Seeker on the Solana dApp Store, Android on Google Play, iPhone on the App Store), one per venue. Each is paste-ready for its venue and states the platform, the philosophy (why a body, why 3D, why AR, why on-chain, why mobile), the whole feature inventory, every programme and partner with its exact designation, and the roadmap.++| File | Venue | Angle |+| --- | --- | --- |+| [x-article.md](x-article.md) | X long-form Article from @trythreews | Community and Seeker owners. Narrative, founder voice, the full $THREE section with the contract address. |+| [coinmarketcap-article.md](coinmarketcap-article.md) | CoinMarketCap Community | Crypto-native reader. Ownership, the x402 economy, agent wallets, the launchpad, the full $THREE section. H2/H3 only and no tables, which is all the CMC editor supports. |+| [aws-builder-center-article.md](aws-builder-center-article.md) | AWS Builder Center (@threews) | Engineers with a web product being asked for an app. Real source for every piece: MWA session persistence, Seeker Genesis Token verification, the share-target worker, deep-link routing, the widget token, the AWS SDK v3 S3 client, the Marketplace front door. |+| [nvidia-forum-article.md](nvidia-forum-article.md) | NVIDIA Developer Forums showcase | GPU operators. The lanes on L4 and Blackwell, the memory ceilings, the NIM models around the generator, on-device gating before the GPU. |+| [ibm-community-article.md](ibm-community-article.md) | IBM Community, Three.ws User Group blog | Developers running Granite on watsonx.ai as an agent brain. Every Granite surface, the pay-per-call path, the trust layer. |++## Facts to know before posting++- **Store status is written as live in all five, on the owner's instruction (2026-09-01).** As of writing, [seeker-app.md](../seeker-app.md) records the Solana dApp Store release as approved and live (v1.0.0, submitted 2026-08-28), [solana-mobile/publish-play/README.md](../../solana-mobile/publish-play/README.md) records the Google Play track as closed testing, and [ios-app.md](../ios-app.md) records the iOS app as in-repo and not yet submitted. Post each article only once its store claims are true; the copy does not hedge, so it will read as false if posted early.+- **The iOS widget and push are described as next, not shipped.** Android and Windows 11 glance widgets are live ([native-widgets.md](../native-widgets.md)); the WidgetKit extension and the APNs path are roadmap.+- **Partner designations are exact and must survive edits.** "OpenAI Select Partner", "member of NVIDIA Inception" (never "NVIDIA partner"), "IBM Business Partner" with the public-showcase caveat, "AWS Partner" with the Marketplace listing described as coming, "member of Google Cloud for Web3 Startups". The rules are in [partners.md](../partners.md).+- **The IBM and NVIDIA pieces deliberately carry no token contract address.** [ibm.md](../ibm.md) sets the user group's content rule (standalone developer content, no crypto-cluster posts), and the NVIDIA venue is a developer showcase. Both describe the on-chain identity and x402 layers as architecture. The X and CoinMarketCap pieces carry the full $THREE section.+- **Numbers are as of late August 2026** and come from [the-first-19-weeks.md](../the-first-19-weeks.md) and [three-thesis.md](../three-thesis.md). Refresh them from those two files before a later posting.+- **Posting is owner-gated** (external-channel gate in [CLAUDE.md](../../CLAUDE.md)). When an article goes live, record its canonical URL here, add it to `data/rss/items.json`, and log it in `data/changelog.json` with the `docs` tag, following the checklist in [aws-builder-center.md](../aws-builder-center.md).++## Sources++The apps: [seeker-app.md](../seeker-app.md), [ios-app.md](../ios-app.md), [native-widgets.md](../native-widgets.md), [glance.md](../glance.md), [solana-mobile/README.md](../../solana-mobile/README.md), [ios/README.md](../../ios/README.md). The platform: [STRUCTURE.md](../../STRUCTURE.md), [how-it-works.md](../how-it-works.md), [forge-pipeline.md](../forge-pipeline.md), [selfie-to-avatar.md](../selfie-to-avatar.md), [ar.md](../ar.md), [irl.md](../irl.md), [x402.md](../x402.md), [onchain-agents.md](../onchain-agents.md), [hold-to-access.md](../hold-to-access.md). Partners and models: [partners.md](../partners.md), [nvidia-models.md](../nvidia-models.md), [nvidia-inception.md](../nvidia-inception.md), [ibm.md](../ibm.md), [ibm-x402-mcp.md](../ibm-x402-mcp.md), [aws-builder-center.md](../aws-builder-center.md). Earlier launch copy the tone follows: [marketing/seeker-launch/post.md](../../marketing/seeker-launch/post.md), [marketing/android-launch/kit/post.md](../../marketing/android-launch/kit/post.md).diff --git a/docs/mobile-launch/aws-builder-center-article.md b/docs/mobile-launch/aws-builder-center-article.mdnew file mode 100644index 000000000..6db759e34--- /dev/null+++ b/docs/mobile-launch/aws-builder-center-article.md@@ -0,0 +1,305 @@+---+venue: AWS Builder Center+account: three.ws (official organization account, @threews)+suggested_title: "One web product, three native apps, zero forks: how three.ws shipped to the Solana Seeker, Android, and iPhone"+suggested_description: "How an open-source WebGL platform for 3D AI agents became three store apps without forking its codebase: a Trusted Web Activity, a Capacitor shell, a native layer that ships with the site, hardware-backed wallet signing, and a home screen widget that outlives every session. All real source you can read."+suggested_tags: [mobile, agentic-ai, blockchain, open-source, javascript]+suggested_canonical: https://three.ws/docs/mobile-launch/aws-builder-center-article.md+status: draft, owner approval required before publishing (external-channel gate in CLAUDE.md)+---++# One web product, three native apps, zero forks: how three.ws shipped to the Solana Seeker, Android, and iPhone++three.ws is an open-source platform that gives an AI agent a 3D body, an on-chain identity, a wallet, and a way to get paid. It is a WebGL product: three.js renders a rigged, animated character in the browser, an LLM drives it, and the whole thing embeds anywhere with one web component. For five months it lived in a browser tab. It is now three native apps: one on the Solana dApp Store for the Seeker phone, one on Google Play for every Android device, and one on the App Store for iPhone.++This is the engineering story of that launch, written for builders who have a web product and are being asked "when is the app coming?" It covers the constraint that ruled out the obvious answer, the shape we chose instead, and the six pieces of native behaviour that turned a full-screen web view into something a store reviewer and a user both recognise as an app. Every code sample is real source from [the repository](https://github.com/nirholas/three.ws); nothing here is aspirational.++It also covers, honestly, where AWS fits. The API runs on Google Cloud Run. Storage goes through the AWS SDK for JavaScript v3 against an S3-compatible store. The AWS Marketplace integration is the enterprise front door to the same API these apps consume. We are an AWS Partner and we write here because this is where AWS builders go to check whether an integration is real.++## Why we built it at all++Before the architecture, the reason. three.ws exists because every AI product of the last three years is a text box, and humans do not experience presence through text. We experience it through faces, posture, gaze. So the platform gives the AI a body: a real rigged character with fifty-two facial blendshapes, generated from a selfie or a sentence, animated on any skeleton, renderable in a browser, in a web component, or standing on your floor in AR.++Once you decide the AI has a body, mobile is not a channel. It is where the inputs live. The camera that takes the selfie is on the phone. The wallet is on the phone. The share sheet is on the phone. The AR camera and the GPS are on the phone. The home screen, where a widget can show you your agent's day without opening anything, is on the phone. A desktop browser can render the product; it cannot take the selfie, walk into the room, or sign without an extension.++And the on-chain layer is there because an agent that lives only in someone's SaaS dashboard cannot be verified at a distance, cannot outlive the vendor, and cannot transact without a human holding keys. A public ledger gives it a stable identity, an owner, a wallet, and a signed history. On Solana that is a Metaplex Core asset; on EVM chains it is an ERC-8004 token at one deterministic CREATE2 address on twelve mainnets. Payments settle over x402, HTTP 402 revived as a machine-to-machine rail, in USDC, with no API key and no human in the loop.++That is the product. Now the constraint.++## The constraint that ruled out a "real" native app++The obvious answer to "build the app" is to bake the built `dist/` into a binary and serve it from a local origin. We could not do that, for a reason that is worth stating precisely because it applies to most serious web products.++There are 733 call sites in `src/` that fetch same-origin `/api/...` paths. The session cookie, the OAuth callbacks, and the x402 payment headers are all issued for the `three.ws` origin. Rewriting every one of them behind an API base URL, and then teaching the auth server, the payment facilitator, and the wallet redirects about a second origin, is a larger and riskier change than shipping the app, and it forks the web and app code paths permanently. Every future feature would ship twice.++So the rule became: the app is a shell around the live product, and the native layer is everything the web cannot do. On Android that shell is a Trusted Web Activity. On iOS it is a Capacitor 8 container whose WKWebView loads `https://three.ws`. On desktop it is the installed PWA. One codebase, one deploy, three stores.++The consequence we like most: app behaviour ships on a web deploy, not a store release. The consequence to design around: an old web deploy means an app with no native behaviour. It degrades to a plain WebView rather than breaking, but the shims are simply absent, so the native layer has to be written as progressive enhancement, keyed off a signal that exists only inside the app.++On iOS that signal is `window.Capacitor`, which Capacitor injects into the remote page at document start. The bridge module ships with the site and is a no-op in every browser:++```js+export function isNativeIOS() {+ const cap = globalThis.Capacitor;+ return Boolean(cap && typeof cap.isNativePlatform === 'function' && cap.isNativePlatform());+}+```++On Android the equivalent probe is whether the page is running inside the TWA and whether Mobile Wallet Adapter is available. Everything below hangs off those two checks.++## Piece 1: a wallet whose key never enters the process++The Seeker is a Solana phone with a hardware-isolated secure element, the Seed Vault. Inside the app, the browser does not inject `window.solana` the way an extension would. Signing has to be delegated to the Seed Vault over the Mobile Wallet Adapter protocol.++The existing three.ws wallet code was written against the injected-provider shape (`connect()`, `signMessage()`, `signTransaction()`), and we did not want to touch it. So the MWA wrapper exposes that same shape and is installed at `window.threeWsWallet` only when the page is inside the TWA:++```js+async connect({ onlyIfTrusted = false } = {}) {+ if (this.isConnected) return { publicKey: this.#publicKey };+ if (this.#connecting) return this.#connecting;++ this.#connecting = (async () => {+ const transact = await loadTransact();+ const authToken = this.#authToken;+ const onlyResume = onlyIfTrusted && Boolean(authToken);+ if (onlyIfTrusted && !authToken) {+ const err = new Error('No prior MWA session to resume');+ err.code = 4001;+ throw err;+ }+ try {+ await transact(async (wallet) => {+ const result = authToken+ ? await wallet.reauthorize({ auth_token: authToken, identity: APP_IDENTITY })+ : await wallet.authorize({+ identity: APP_IDENTITY,+ chain: this.#chain,+ features: ['solana:signTransactions', 'solana:signMessages'],+ });+ this.#applyAuthResult(result);+ });+ } catch (err) {+ if (onlyResume) {+ this.#reset();+ }+ throw normalizeMwaError(err);+ }+ return { publicKey: this.#publicKey };+ })();++ try {+ return await this.#connecting;+ } finally {+ this.#connecting = null;+ }+}+```++Three decisions in that function are the difference between a demo and an app.++**The auth token is persisted in `localStorage`, not `sessionStorage`.** Android kills a backgrounded TWA process freely, and `sessionStorage` dies with it. Our first build prompted the Seed Vault on every relaunch, which felt like a broken app. MWA auth tokens are designed to be persisted so the app can `reauthorize()` silently; we just had to store them somewhere that survives process death.++**A revoked token is dropped on the first failed `reauthorize`.** If the user revokes the session in the wallet, the next silent resume fails, the wrapper resets, and it emits `disconnect`. The caller decides whether to prompt again. No zombie sessions.++**Every error is normalised to the shape the rest of the code already handles.** A Seed Vault cancel becomes `code === 4001`, exactly what a Phantom cancel produces, so not one line of existing error handling changed.++Sign-in itself is one interaction. The Seed Vault supports Sign-In With Solana at authorize time, so the wrapper's `signIn()` passes a `sign_in_payload` and gets back a signed message in the same prompt, collapsing the usual connect-then-sign into one sheet. Injected wallets on desktop fall back to the two-step flow automatically.++## Piece 2: proving hardware ownership without a transaction++Solana Mobile mints a soulbound Seeker Genesis Token, a Token-2022 asset, into each device's primary Seed Vault account once. Holding one proves the wallet belongs to a Seeker owner. We wanted a "Seeker verified" badge on every agent such a user owns, and we wanted it without asking the user to sign or send anything.++The check is a read. The server lists the linked wallet's Token-2022 accounts, then inspects each mint for the three properties Solana Mobile's reference logic specifies:++```js+export function isSeekerGenesisMint(parsedMintAccount) {+ const data = parsedMintAccount?.data ?? parsedMintAccount;+ const parsed = data?.parsed;+ if (!parsed || parsed.type !== 'mint') return false;+ if (parsedMintAccount?.owner && parsedMintAccount.owner !== SGT_TOKEN_2022_PROGRAM) return false;+ const info = parsed.info || {};+ if (info.mintAuthority !== SGT_MINT_AUTHORITY) return false;+ const extensions = Array.isArray(info.extensions) ? info.extensions : [];+ const pointer = extensions.find((e) => e?.extension === 'metadataPointer');+ const member = extensions.find((e) => e?.extension === 'tokenGroupMember');+ if (!pointer || !member) return false;+ if (pointer.state?.metadataAddress !== SGT_GROUP) return false;+ if (member.state?.group !== SGT_GROUP) return false;+ return true;+}+```++The function is pure, so it is unit-tested against fixture accounts without a network. The network half fails closed: every RPC error throws, the handler turns it into a `502 rpc_failed`, and the module never answers "not a Seeker" because the RPC was down. A verification badge that can be false-positive by outage is worse than no badge. Verified wallets are recorded once in Postgres so the badge renders on every agent page without a chain read.++The handler is a normal session-mutating route: it requires the session, requires a CSRF token so a cross-site form post cannot trigger a rescan on someone's behalf, and rate-limits by IP.++## Piece 3: the share sheet as an input device++The single most-used input to three.ws on a phone is a photo, and the shortest path from a photo to the product is the system share sheet. The web manifest declares a `share_target` at `POST /create/share`, and the TWA registers the same target with Android, so three.ws appears in the share sheet for images and `model/gltf-binary` files.++No server ever sees that POST. The service worker intercepts it, parks the files in the Cache API, and redirects to the flow that fits the first file:++```js+function shareTargetDestination(files) {+ if (!files || files.length === 0) return '/create';+ const first = files[0];+ if (isGlbFile(first)) return '/create?shared=glb';+ if (isImageFile(first)) return '/create/selfie?shared=1';+ return '/create?shared=1';+}+```++A shared image lands in the selfie scanner with the frontal slot filled; a second and third image fill the optional side angles. A shared `.glb` lands in the upload flow. The handoff is one-shot and expires after ten minutes, so a stale share can never resurface as a new one, and the page strips the query parameter after it reads the files so a reload does not look like a fresh share.++On iOS the direction is reversed. `WKWebView` has no Web Share API, so every share button on the platform would silently do nothing. The bridge installs `navigator.share` over the native sheet, writing any attached files to the app's cache directory first so an AR capture arrives as a real image, not a URL:++```js+navigator.share = async (data = {}) => {+ const files = Array.isArray(data.files) ? data.files : [];+ const uris = [];+ for (const file of files) {+ const uri = await blobToCacheUri(file);+ if (uri) uris.push(uri);+ }+ await share.share({+ title: data.title || undefined,+ text: data.text || undefined,+ url: data.url || undefined,+ files: uris.length ? uris : undefined,+ dialogTitle: data.title || 'Share',+ });+};+```++## Piece 4: deep links that cannot be hijacked++Any `https://three.ws/...` link should open inside the app. On Android that is Digital Asset Links: the app's signing certificate fingerprint is published at `/.well-known/assetlinks.json`, and Android verifies it on install. If the file and the APK disagree, links stay in the browser. We serve that file with a short cache lifetime on purpose, because a stale copy after a key rotation silently breaks every link.++Google Play adds a trap with no local symptom: Play re-signs the bundle with Google's own key, so Google's certificate fingerprint has to be in the published file too, or every Play install loses full-screen mode while the dApp Store build stays perfect. The build script generates `assetlinks.json` from every certificate in an `extra-fingerprints.json` list for exactly this reason.++On iOS the equivalent is the `apple-app-site-association` file, and Apple requires an exact path, a JSON content type, and no redirect, so it is served by an API handler rather than from the static directory. Until the Apple Team ID is configured on the service, the endpoint answers `503 not_configured` deliberately, because publishing an association for a team that cannot sign anything fails silently on device.++Once a link is caught, it arrives in the page as an event, not a navigation, and that event is an entry point any installed app can call. So the router refuses anything off-domain:++```js+app.addListener('appUrlOpen', (event) => {+ const raw = event?.url;+ if (!raw) return;+ let target = null;+ try {+ const url = new URL(raw);+ if (url.protocol === 'threews:') {+ const path = `${url.hostname ? `/${url.hostname}` : ''}${url.pathname}`;+ target = `https://three.ws${path || '/'}${url.search}${url.hash}`;+ } else if (INTERNAL_HOSTS.has(url.hostname)) {+ target = url.href;+ }+ } catch {+ return;+ }+ if (!target) return;+ if (target === location.href) return;+ location.assign(target);+});+```++The `threews://` scheme exists for one reason: a wallet or OAuth redirect has to come back to the exact page that started it, and a custom scheme is the one thing another app can open reliably.++## Piece 5: a widget that outlives every session++A home screen widget is what makes an app worth keeping installed between visits. Ours, Agent glance, shows your agent's avatar, its name, and how many moves it made today, in three sizes. Two facts about widgets shaped the whole design.++**No widget host on any platform can run WebGL.** So the card is a bitmap the server renders: `GET /api/glance/mine?format=png`. The 3D avatar stays one tap away on the agent page.++**A widget outlives every browser session, and Android fetches it from an OS process with no cookie jar.** So it cannot use the session. Instead the Glance page mints a widget token: a random 32-character credential prefixed `glw_`. The server stores only its SHA-256. The plaintext travels once, inside a `threews://glance/link?token=...` deep link that only our package can claim, and then lives in the app's private storage. The token is accepted by exactly one endpoint and reads exactly one thing, the owner's card. Every linked widget is listed on the Glance page with a revoke button, and a revoked token turns the widget into a "Widget unlinked" card whose tap re-opens the link flow.++The refresh is a WorkManager job, and failure is the designed path:++```java+/**+ * The refresh. WorkManager runs it every 30 minutes while a widget is placed+ * (battery-aware, coalesced with the system's other periodic work) and once+ * on demand after a link or a tap on "refresh". It fetches one bitmap per+ * size currently on screen, writes each one atomically, and then repaints+ * every widget instance.+ *+ * Failure is the designed path: no network, a timeout, a 5xx all return+ * retry, the cached bitmap stays on screen, and the footer says the card is+ * from earlier. Nothing here ever clears a card it cannot replace.+ */+public final class GlanceRefreshWorker extends Worker {+```++The endpoint follows the same rule from the other side. It always returns 200. The state (signed out, unlinked, no agent yet, live) travels in an `x-glance-state` header and the tap target in `x-glance-url`, so the native side never has to parse an error body to decide what to draw. Every non-agent state is a designed card, never a 401.++The five checks we run in an emulator before a release: add the widget from the picker, watch it refresh with no app UI open, force-stop the app and confirm the card stays, enable airplane mode and confirm the footer reads "(offline)" with the card intact, reboot and confirm it comes back.++## Piece 6: the details a reviewer notices++Six small things in the iOS bridge, each fixing a specific breakage:++- Off-site links open in an in-app Safari sheet and return, instead of navigating the app's only WebView away with no back button.+- The splash screen hides on first paint of the scene, not on WebView load, because `launchAutoHide` fires minutes before a three.js scene renders and the user would see a black void.+- The sticky header gets status-bar padding by injected stylesheet, because the site's own compensation is behind `@media (display-mode: standalone)`, which a WKWebView loading a remote URL never matches.+- Form fields never fall below 16px, so focusing one cannot zoom the page and strand it zoomed.+- Haptics tick on primary and destructive actions and stay quiet on disabled or busy ones.+- Edge-swipe back and forward are enabled in a replacement view controller, because `WKWebView` ships with them off and iOS has no back button.++Two trade-offs were decided rather than discovered. `WKWebView` runs service workers only for app-bound domains, and the app declares none, so the site's offline cache and share-target worker do not run inside it; a native offline screen that polls `/api/healthz` covers the case that matters. And `SFSafariViewController` does not share the app WebView's cookie jar, so any surface routed to Safari arrives signed out; the reasoning is written down in the repo's review-risk document so nobody re-litigates it by accident.++## Where AWS fits++Plainly: the three.ws API is one container on Google Cloud Run that serves the static frontend, a route table, and every API handler, with crons on Cloud Scheduler and GPU model workers on their own services. That is not going to change, and pretending otherwise would waste your time.++Two parts of the stack are AWS SDK code, and one is an AWS Marketplace integration.++**Object storage goes through `@aws-sdk/client-s3`.** Every generated GLB, every avatar thumbnail, every audio upload is written with `PutObjectCommand` and read back through presigned URLs from `@aws-sdk/s3-request-presigner`. The client is configured for an S3-compatible endpoint and works unchanged against AWS S3. One gotcha cost us an afternoon and is worth passing on:++```js+_r2 = new S3Client({+ region: 'auto',+ endpoint: env.S3_ENDPOINT,+ credentials: {+ accessKeyId: env.S3_ACCESS_KEY_ID,+ secretAccessKey: env.S3_SECRET_ACCESS_KEY,+ },+ // AWS SDK v3 >= 3.730 adds CRC32 to every PutObject by default.+ // Browsers can't compute/send that header, so presigned PUT URLs+ // would be rejected by R2. Opt out until we add client-side CRC32.+ requestChecksumCalculation: 'WHEN_REQUIRED',+ responseChecksumValidation: 'WHEN_REQUIRED',+});+```++The mobile apps upload selfies and audio straight to presigned PUT URLs from the phone. If your uploads started failing after an SDK bump, the checksum default is the first thing to check.++**AWS Marketplace is the enterprise front door.** The SaaS integration is built and deployed: `ResolveCustomer` on the fulfillment URL, EventBridge agreement and license events for lifecycle, account linking after the post-subscribe redirect, and entitlement checks through `@aws-sdk/client-marketplace-entitlement-service`. The subscription is deliberately a free front door: it links an AWS account to a three.ws account and issues an x402 access key, and usage is then paid per call in USDC over x402. AWS Marketplace does not meter or bill the usage. We wrote that integration up in detail in an earlier Builder Center article, and the listing itself is coming.++The point for a builder: the apps in this article and a Marketplace buyer's agent hit the same API, the same 402 challenges, and the same access check. There is one authorization path, and it serves a phone in someone's hand and a headless agent in someone's VPC.++## What the apps plug into++The shell is only interesting because of what is inside it. From the phone, with no wallet:++- **Forge.** A prompt, up to six photos, or a sketch becomes a textured GLB. The draft lane is free and keyless and finishes in about twelve seconds on NVIDIA's hosted TRELLIS lane; paid lanes go to 200,000 polygons with PBR materials at $0.05, $0.15, and $0.50 in USDC over x402. Every lane has a failover chain with health-gated circuit breakers, and a lane that dies mid-job is re-dispatched under the same job id.+- **Scan.** One frontal selfie becomes a rigged avatar in about a minute, with a Mixamo-compatible skeleton and the ARKit-52 blendshape set. A 468-point face mesh runs on-device and gates lighting, framing, blur, and highlight clipping before the GPU minute is spent; every threshold traces to a real reconstruction failure mode and two of them were calibrated against measured photographs.+- **Agents.** A personality, a voice, skills, and memory on any character, driven by an LLM tool loop capped at eight iterations per turn, with a fifteen-rung free-first provider chain and a Vertex Gemini anchor. Claude, GPT, Gemini, Qwen, IBM Granite, and NVIDIA Nemotron are all selectable brains.+- **Animation as infrastructure.** A skeleton canonicalizer maps Mixamo, Avaturn, VRM, Unreal, Daz, MakeHuman, and Blender conventions onto one canonical rig, and a retargeter drives a library of more than three thousand clips onto any of them. There is no allowlist.+- **AR and IRL.** Quick Look, Scene Viewer, or WebXR on the first tap; agents pinned to real GPS coordinates that only people physically present can see, talk to, and pay.+- **Worlds.** A persistent multiplayer world on an authoritative Colyseus server, 15 Hz binary deltas, proximity-gated WebRTC spatial voice, 3,145 peak concurrent avatars at the first community meetup.+- **Embeds.** One `<agent-3d>` web component, ten iframe widget types, oEmbed unfurls, 101 npm packages, 72 MCP servers in the official registry, and an OAuth 2.1 server so any assistant can drive the platform.+- **The economy.** Custodial agent wallets with one spend-policy module at the signing boundary, x402 endpoints settling USDC on Solana through a self-hosted facilitator (110,416 settlements and 803,483 verifications as of late August), 4,519 priced endpoints in the live catalog, a marketplace, a labour market, vaults, and a launchpad an agent can call for a flat $5 with no wallet of its own.++All of it is Apache-2.0. The platform has shipped roughly twenty changes a day since April, with every user-visible one in a public changelog that pushes itself to the community channel from the deploy.++## Who made it possible++three.ws is an AWS Partner, a member of NVIDIA Inception, an OpenAI Select Partner, an IBM Business Partner, a member of Google Cloud for Web3 Startups, an Alibaba Cloud Partner Network member, and a member of the Quicknode Startup Program. Solana Mobile built the phone, the store, and the wallet protocol this launch was designed around. Each of those is a programme membership or partner designation, stated exactly; none is an endorsement of this product, and the code that runs on each platform is ours.++## What is next++The Android and Windows widgets exist; a shared WidgetKit extension brings the same card to the iPhone home screen and the macOS widget gallery against the same endpoint and token. Push notifications on iOS have the entitlement and background mode in place and are waiting on the APNs path, which is absent rather than stubbed. Likeness fidelity in the selfie engine is the open research track. Voice cloning moves from the demos hub into the main flow. And the open inference network, a node-operator client that returns signed receipts the coordinator recomputes, is the beginning of a GPU layer no single company runs.++If you have a WebGL product and a "when is the app coming" question, the whole answer is in the repository: the TWA packaging under `solana-mobile/`, the Capacitor shell under `ios/`, and the native bridge that ships with the site. Read it, run it, and tell us what we got wrong.++[github.com/nirholas/three.ws](https://github.com/nirholas/three.ws)diff --git a/docs/mobile-launch/ibm-community-article.md b/docs/mobile-launch/ibm-community-article.mdnew file mode 100644index 000000000..adec8a09b--- /dev/null+++ b/docs/mobile-launch/ibm-community-article.md@@ -0,0 +1,119 @@+---+venue: IBM Community, Three.ws User Group (blog post)+account: three.ws (official)+suggested_title: "Your Granite-brained agent, now in your pocket: three.ws on Solana Seeker, Android, and iPhone"+description: "three.ws is now three native apps. This post walks through what changed for a developer running IBM Granite on watsonx.ai as an agent's brain, how the phone reaches that brain, the trust layer around it, and everything the platform has shipped since April."+status: draft, owner approval required before posting (external-channel gate in CLAUDE.md)+---++# Your Granite-brained agent, now in your pocket: three.ws on Solana Seeker, Android, and iPhone++_A note on framing before anything else. three.ws is an IBM Business Partner, and a three.ws agent can think on IBM Granite foundation models served through IBM watsonx.ai using your own IBM Cloud credentials. Everything under `/api/ibm/*` and the Granite connectors described here is an independent set of developer tools three.ws built on IBM's publicly available Granite models. They are not IBM products, not official partnership deliverables, and not endorsed by IBM. This user group is a community space three.ws moderates on IBM's platform, not an IBM product._++three.ws is the open-source platform this group is built around: an AI agent gets a 3D body, a mind, a memory, an identity that outlives any one host, and a way to be embedded anywhere. It is now three native apps. One ships on the Solana dApp Store for the Seeker phone, one on Google Play for every Android device, and one on the App Store for iPhone. Same product, same account, same agent library, three home screens.++This post is written for the developer in this group who has an agent running on Granite and wants to know what the phone changes, and for the developer who has not tried it yet and wants the whole picture in one read: why we built the platform, why the body and the phone and the ledger all belong in it, exactly how Granite fits, and what has shipped in the five months since the first commit.++## Why an agent needs a body, and why the body needed a phone++Every AI product of the last three years is a text box. That is a fine interface for retrieval and a strange one for an agent: a thing with a name, a personality, a memory, a job. Humans experience presence through faces, posture, and gaze, and no amount of prompt engineering changes that wiring. So three.ws gives the agent a real rigged 3D character with fifty-two facial blendshapes, generated from a selfie or a sentence, animated on any skeleton, renderable in a browser, a web component, or standing on your floor in augmented reality.++Once the agent has a body, the phone stops being a channel and becomes the place where the inputs live. The camera that takes the selfie is on the phone. The share sheet is on the phone. The AR camera and the GPS are on the phone. The home screen, where a widget can show you your agent's day without opening anything, is on the phone. A desktop browser renders the product well; it cannot take the selfie, walk into the room, or stand at the park bench where an agent has been pinned.++## The three apps, briefly++All three are shells around the live web product rather than second implementations, because a WebGL product with 733 same-origin API call sites cannot sensibly be forked. The native layer is everything a website cannot do.++**Solana Seeker.** A Trusted Web Activity: the real three.ws full screen, with every wallet interaction routed to the phone's hardware-isolated Seed Vault through Mobile Wallet Adapter, so a private key never enters the app process. Share a photo from any app and it opens the selfie flow with the photo attached; share a .glb and it opens the upload flow. Any three.ws link opens in the app, verified through Digital Asset Links. The app reads the soulbound Seeker Genesis Token to badge verified Seeker owners, and the check fails closed on any RPC error rather than guessing.++**Android.** The same package for every phone from Android 6 up, 3.95 MB, with signing delegated to whatever wallet app the user already trusts. Version 1.1 added Agent glance, a home screen widget in three sizes that shows the agent's avatar, its name, and how many moves it made today, refreshed by WorkManager about every thirty minutes, kept on disk when the phone is offline, and revocable from the web with its own single-purpose token.++**iPhone.** A Capacitor container whose WebView runs the live site, wrapped in universal links, the system share sheet with AR captures as real files, wallet and sign-in redirects that return to the exact page that started them, haptics, edge-swipe navigation, and real camera and motion permission prompts. The native bridge ships with the site, so the app improves on every web deploy.++## Where Granite fits: the brain++watsonx Granite is a selectable brain for any three.ws agent, alongside the other providers. 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, on the phone exactly as on the desktop. The phone does not know which brain it is talking to; it talks to the same origin the web app does, and the origin routes.++One IBM Cloud key and one project unlock the whole suite. The variables, set locally in `.env` or on the production service:++```+WATSONX_API_KEY= # IBM Cloud API key from cloud.ibm.com/iam/apikeys+WATSONX_PROJECT_ID= # or WATSONX_SPACE_ID+WATSONX_URL=https://us-south.ml.cloud.ibm.com+WATSONX_MODEL_ID=ibm/granite-3-8b-instruct+WATSONX_EMBED_MODEL_ID=ibm/granite-embedding-278m-multilingual+WATSONX_VISION_MODEL_ID=ibm/granite-vision-3-2-2b+WATSONX_GUARDIAN_MODEL_ID=ibm/granite-guardian-3-8b+WATSONX_API_VERSION=2024-05-31+```++Regions `eu-de`, `eu-gb`, `jp-tok`, `au-syd`, and `ca-tor` work by changing the URL. There is no mock path anywhere in the integration: a missing key returns a `503` with the real reason, never a fabricated answer.++The same models are reachable from any MCP-capable client through the community connector:++```+WATSONX_API_KEY=... WATSONX_PROJECT_ID=... npx @three-ws/ibm-watsonx-mcp+```++It reads the same variables. It is community-built; IBM does not operate or endorse it.++## Where Granite fits: the surfaces around the brain++The brain is one Granite model. Five more do work around it, each behind a live endpoint you can call today.++**Governance, with Granite Guardian.** `granite-guardian-3-8b` sits behind the Guardian trust layer. It assesses text, message threads, and proposed agent actions against a named set of risks and returns a verdict. The endpoint is rate-limited to thirty requests a minute per IP with an hourly platform-wide ceiling on watsonx inference that only real assessments charge, and it answers `503 guardian_unconfigured` when no key is present, because a governance layer that invents a verdict is worse than none.++**Semantic discovery, with Granite embeddings.** `granite-embedding-278m-multilingual` embeds every public agent, and the Galaxy lays them out as a star map you can search in natural language. The stored vectors live in Granite's space, so there is deliberately no provider failover for search; a vector from another model would be a different geometry. When the embedder is unavailable the endpoint degrades the method instead of failing: it ranks the same corpus lexically and answers `200` with `ranking: "lexical"` and a retryable reason. The standalone `POST /api/watsonx/embed` exposes the same vectors for your own clustering.++**Forecasting, with Granite Time Series.** The `granite-ttm` models (512, 1024, and 1536 context variants) forecast a token's price history in the Oracle endpoint, and `granite-3-8b-instruct` writes a two-sentence narration of the result. Every response carries an `ibm` block reporting which forecast model and input window produced it, or the real error reason when a step is unavailable.++**Vision, with Granite Vision.** `granite-vision-3-2-2b` describes avatars and generated models, and the endpoint ships with a handful of public avatars so an anonymous caller can try it with no upload.++**Digital twins and attestations.** The twin endpoint builds a Granite-narrated model of a token community, and the attest endpoint records Granite-governed assessments as on-chain memos, so a verdict has a signature and a timestamp anyone can check.++## Granite as a paid tool an agent can buy++The part of this that I think matters most to an agent developer is the pay-per-call path. An MCP client can call Granite chat or Granite code generation and pay a few cents in USDC per call over x402, HTTP's 402 Payment Required status revived as a machine-to-machine rail, with no IBM Cloud account of its own. The operator holds the watsonx credentials and funds the inference; the caller pays per call and gets the result. Granite chat is $0.02 a call and Granite code is $0.025, with a free getting-started tool that returns the catalog and prices with no payment. The same tool suite ships over two transports, a hosted remote endpoint and an npm package, with identical schemas and output shapes.++Why this matters for the phone: an agent running in the app has a wallet. It can buy a Granite inference, buy a rig of its own body, or buy a market datapoint, all through the same 402 flow, with the user watching it happen on a phone screen.++## The trust layer the phone inherits++An agent that lives only in one vendor's dashboard cannot be verified at a distance, cannot outlive the vendor, and cannot transact without a human holding keys. three.ws anchors every agent to a public ledger for that reason, and the phone inherits all of it.++- **Identity.** On Solana an agent is a Metaplex Core asset held in the owner's wallet with an open manifest; on EVM chains it is an ERC-8004 token, with identity, reputation, and validation registries deployed at one deterministic address on twelve mainnets. Deploying from the phone is one tap and typically costs under 0.01 SOL, and it is entirely optional: creating, chatting, and browsing never touch a chain.+- **Signed history.** Every meaningful agent action is logged and signed by the agent's delegated signer, so a third party can replay what an agent did without trusting its host.+- **Reputation and validation.** Signed reviews and allow-listed validator attestations live on-chain, minimal by design, with the human-readable content off-chain at a URI.+- **Governance before action.** The Guardian layer above sits in front of autonomous spend. A seven-layer guard chain (blacklist, intervention, capability, permission, trade, spend, x402) runs in the agent runtime SDK with a hash-chained action ledger.+- **Payments.** x402 settles USDC on Solana through a self-hosted facilitator, with Base and BSC legs. As of late August that facilitator had settled 110,416 payments on-chain and verified 803,483, across 4,519 priced endpoints in the live catalog.++None of that requires the user to think about a chain. The Seeker's secure element signs; the Play and iOS apps hand signing to the wallet the user already has; three.ws never sees a key.++## What is in the app, for the developer who has not opened it++Everything on three.ws works from the phone, and none of it needs a wallet.++- **Forge.** A prompt, up to six photos, or a sketch becomes a textured GLB. The draft lane is free and keyless and finishes in about twelve seconds; paid lanes reach 200,000 polygons with PBR materials. Eleven named engines with live health checks and automatic failover.+- **Scan.** One frontal selfie becomes a rigged avatar in about a minute, with a Mixamo-compatible skeleton and the ARKit-52 blendshape set. A 468-point face mesh runs on-device and gates lighting, framing, and blur before the GPU minute is spent.+- **Agents.** Personality, voice, skills, and memory on any character, driven by a tool loop capped at eight iterations per turn. Granite, Claude, GPT, Gemini, Qwen, and NVIDIA Nemotron are all selectable brains.+- **Animation as infrastructure.** A skeleton canonicalizer maps every major rig convention onto one canonical skeleton and a retargeter drives more than three thousand motion-capture clips onto any of them. No allowlist.+- **AR and IRL.** Quick Look, Scene Viewer, or WebXR on the first tap. IRL pins an agent to a real GPS coordinate; only people physically present can see it, talk to it, complete quests it signs, and pay it.+- **Worlds.** A persistent multiplayer world on an authoritative Colyseus server with proximity-gated spatial voice. This group's own August meetup ran there, with 3,145 avatars in the plaza at once.+- **Embeds and SDKs.** One `<agent-3d>` web component, ten iframe widget types, oEmbed unfurls, 101 npm packages, 72 MCP servers in the official registry, an OAuth 2.1 server, and a hosted MCP endpoint any assistant can drive.+- **Glance.** The agent's status card on any surface that cannot run WebGL: the Android home screen, the Windows 11 widgets board, a README, a Slack message, a terminal.++## The platform in numbers++From the first commit on April 14 to the end of August: 761 public pages; more than 2,700 community-readable changelog entries at roughly twenty shipped changes a day; 33 workers on a self-hosted GPU fleet of NVIDIA L4s and an RTX PRO 6000 Blackwell; 1,752 test files; 111 open-source repositories spun out with more than 1,200 stars between them. All Apache-2.0 at [github.com/nirholas/three.ws](https://github.com/nirholas/three.ws).++## The programmes behind it++three.ws is an IBM Business Partner, a member of NVIDIA Inception, an OpenAI Select Partner, an AWS Partner, a member of Google Cloud for Web3 Startups, an Alibaba Cloud Partner Network member, and a member of the Quicknode Startup Program. Solana Mobile built the phone, the store, and the wallet protocol the Seeker app is designed around. Each of those is a programme membership or partner designation, stated exactly; none is an endorsement, and the code that runs on each platform is ours.++## What is next++A shared WidgetKit extension brings the glance card to the iPhone home screen and the macOS widget gallery. Push notifications on iOS have the entitlement in place and wait on the APNs path. Likeness fidelity in the selfie engine is the open research track. Voice cloning moves into the main flow. The on-chain economy's third phase brings agent tokens, reputation markets, and per-call skill royalties. And the open inference network, a node-operator client returning signed receipts the coordinator recomputes, is the beginning of a GPU layer no single company runs.++For this group specifically: if you have a Granite-brained agent, install the app, sign in, and talk to it on your phone. Then put it in your room. Then tell us in the thread what it should be able to do next.++Docs: [three.ws/docs/ibm](https://three.ws/docs/ibm) · Live: [three.ws/ibm/hello](https://three.ws/ibm/hello) · Source: [github.com/nirholas/three.ws](https://github.com/nirholas/three.ws)diff --git a/docs/mobile-launch/nvidia-forum-article.md b/docs/mobile-launch/nvidia-forum-article.mdnew file mode 100644index 000000000..b6a7439f3--- /dev/null+++ b/docs/mobile-launch/nvidia-forum-article.md@@ -0,0 +1,127 @@+---+venue: NVIDIA Developer Forums (community showcase)+account: three.ws (official)+suggested_title: "Three phones, one GPU fleet: shipping generative 3D to the Solana Seeker, Android, and iPhone on L4s, Blackwell, and NIM"+description: "What putting three.ws in a store app taught us about serving text-to-3D, selfie-to-avatar, rigging, and motion from NVIDIA GPUs to a phone: the lanes, the memory ceilings, the models that stand around the generator, and why the phone changed the shape of the problem."+tags: [nim, trellis, nemotron, generative-3d, cloud-run, mobile, inception]+canonical: https://three.ws/docs/mobile-launch/nvidia-forum-article.md+status: draft, owner approval required before posting (external-channel gate in CLAUDE.md)+---++# Three phones, one GPU fleet++I run [three.ws](https://three.ws). You type a sentence or take a selfie, and a rigged, textured 3D character stands in your browser a minute later, ready to walk, talk, and be placed in your room in AR. Every generation lane runs on NVIDIA silicon: our own Cloud Run fleet of L4s and one RTX PRO 6000 Blackwell, plus the hosted NIM catalog for the free lanes and the models that do judgment work around the generator. three.ws is a member of NVIDIA Inception, and I wrote here before about how a 12B vision model in front of the generator mattered more than the generator itself.++This post is about what happened next. three.ws is now three native apps: one on the Solana dApp Store for the Seeker phone, one on Google Play, and one on the App Store. Putting a GPU-backed generative product into a store app on a phone changed the shape of the problem in ways I did not predict, and most of them are about the GPU. I want to walk through the fleet as it is today, the lanes, the ceilings, the models around the generator, and the specific things a phone forced us to get right. Real numbers throughout, and every claim is checkable in the [open-source repository](https://github.com/nirholas/three.ws).++## Why a phone, and why that is a GPU question++A desktop browser renders three.ws perfectly well. But every input to a three.ws agent lives on a phone: the camera that takes the selfie, the photo roll, the share sheet, the AR camera, the GPS that lets an agent be pinned to a park bench, and the wallet. The product wanted to be on a phone from the first commit.++The trouble is that a phone user is the least patient user you have and the phone camera produces the worst input you will ever see. On desktop, a text-to-3D request came from someone who typed a considered prompt. On a phone, it comes from someone standing in a kitchen holding a backlit selfie at arm's length, and if the mesh is noise they do not know the input was unreconstructable; they know the app is broken. Every bad input that reaches the GPU burns a slot, a cold start, and the full generation time, and returns nothing. On a phone, that is the whole retention curve.++So the phone made two things non-negotiable: the judgment has to happen before the GPU, ideally on the device; and the lane has to be fast enough that a person holding a phone will wait for it.++## The fleet as it stands++Every 3D worker is a Cloud Run service with an NVIDIA GPU, scaling to zero when idle, which is most of why a free tier is economically sustainable. What runs where:++**Text-to-3D and image-to-3D.**+- Microsoft TRELLIS on the hosted NIM lane. This is the free draft tier. It finishes a text-to-3D generation inline in about 12 to 13 seconds at 15 sampling steps, with none of the roughly 60-second cold start our self-hosted lanes pay. It is text-only; the hosted preview rejects user images.+- TRELLIS-image-large, self-hosted on an L4, for the image path and the standard tier.+- Tencent Hunyuan3D 2.1, `hy3dshape` plus `hy3dpaint`, the named engine of the high tier because it produces PBR materials. More on where it actually runs below.+- TripoSR on an L4 as the fast fallback, roughly 5 to 15 seconds.+- TripoSG and TripoSG-scribble, a 1.5B rectified-flow transformer, for the sketch path, with RMBG-1.4 in front for background removal.++**Rigging.** Make-It-Animatable on an L4: a 52-bone Mixamo-compatible skeleton, skin weights, and ARKit-52 blendshapes from the ICT-FaceKit set. Any generated humanoid goes through it, so every character that comes out of the pipeline can walk, emote, and lip-sync.++**Photo-to-avatar.** The reconstruction worker carries two paths: a template-fit pipeline that runs MediaPipe FaceLandmarker's 468 landmarks to transfer a face's texture and geometry onto a fixed-topology, pre-rigged humanoid (the production lane, about a minute), and a multi-view path built on InstantMesh with Zero123++ synthesising six views from one to six photos.++**Motion.** A text-to-motion worker on the Motion Diffusion Model with the HumanML3D checkpoint, a video-to-motion worker, and a video-to-scene worker that turns a phone video into a point cloud.++**CPU workers around them.** Background removal (BRIA RMBG-2.0), stylisation (voxel, brick, voronoi, low-poly, all pure geometry), segmentation, and a remesh worker with QuadriFlow and xatlas that also handles the GLB, OBJ, FBX, STL, PLY, USDZ, and 3MF conversions a phone's AR viewer needs.++All of it sits behind one tier table: draft at 12,000 polygons with no textures, standard at 30,000 with 2K textures, high at 200,000 with PBR and HD. The tier picks a named free default per path, then walks a per-path free fallback chain, and only then reaches for a paid lane.++## The L4 memory ceiling, and where Blackwell earns its keep++The single hardest constraint in the fleet is not compute, it is the 32 GiB ceiling on a Cloud Run L4 instance and the regional quota bucket every L4 service draws from.++Hunyuan3D 2.1 is the clearest example. Its weight staging needs about 18 GiB of tmpfs on top of a 14 GiB model, and that combination OOMs the L4 ceiling with a signal 9 mid-load. The L4 build of the 2.1 worker is known-broken for real jobs and stays at zero instances. The lane that actually serves the high tier is a separate service on the RTX PRO 6000 Blackwell, which has the memory to hold both halves of the model resident. That one service is the reason the high tier exists.++Two operational facts about that Blackwell lane are worth knowing if you are planning a fleet:++1. The RTX PRO 6000 quota is enforced at one instance regardless of the granted preference value. Asking for more instances fails with `requested: 4 allowed: 1`. We treat the preference number as aspirational.+2. The accelerator type lives in the service's node selector, not in the template annotations. Reading the wrong place silently defaulted every service to L4 in our capacity tooling and charged the Blackwell service to the L4 pool, which made a region read as fully pinned when it had a spare L4. That mistake is now pinned by a test.++The L4 grant itself went from 6 to 22 instances across regions in July, and the blocker on the raise turned out to be a CLI flag rather than a policy. Two other regions were granted 8 each instantly.++And one lesson we learned twice, in two regions: warm pins are per region, and an idle standby in a region starves the lane that region actually serves. We pinned Hunyuan3D warm on an L4 in a region whose only production-routed lane was text-to-motion, and that lane logged 13 allocation denials in a week, most of them from the ten-minute keep-warm probe, while the standby sat idle with zero jobs in three days. Before pinning any GPU service warm, check which environment variable routes production traffic to that region.++## Failover is the product, not a feature++A phone user who waits sixty seconds for a cold start and then gets an error does not come back. So every lane has a health-gated failover chain, and the chain is shared across instances.++- `resolveBackendIdWithHealth()` walks the ordered lane list and skips any lane confirmed down.+- Per-lane circuit breakers put a lane on a 90-second cooldown after a failure; NIM lanes get 120 seconds per model and 30 seconds for the gateway.+- Poll-time failover re-dispatches a lane that dies mid-job under the same job id, so the phone keeps polling the same handle and never sees the swap.+- A subject-aware reorder at the high tier hoists the self-hosted TRELLIS lane for hard-surface prompts and keeps Hunyuan3D first for organic ones, because they are genuinely better at different things.+- The job id lives in the phone's local storage and is resumable for thirty minutes, so backgrounding the app, which Android does freely, does not lose the generation.++## The models standing around the generator++The 3D model is a single API call. What made text-to-3D usable was a set of small NVIDIA models doing judgment work, all unlocked by one `nvapi-` key on the hosted catalog:++- **Nemotron Nano 12B v2 VL** looks at the input before any GPU minute is spent: is there a subject, is it reconstructable, is this a bar chart. On the phone this matters more than anywhere, because the phone camera is where the bar charts and the six-object living rooms come from.+- **Nemotron 3 Super 120B-a12b** is the default LLM lane behind agent chat, with Nemotron 3 Nano 30B-a3b as the compact rung, and a garden of Llama-3.3-Nemotron 49B, Nemotron Nano 9B, Llama 4 Maverick, DeepSeek V4 Pro, Kimi K2.6, and MiniMax M2.7 selectable per agent.+- **FLUX.1-dev** paints a prompt into a reference view for the image path.+- **nv-embedqa-e5-v5** produces the 1024-dimensional embeddings behind agent memory and semantic search; **rerank-qa-mistral-4b** reranks, opt-in and fail-open.+- **Llama 3.1 NemoGuard 8B content safety** screens everything the official account publishes outbound, alongside Llama Guard 4. It is scoped to outbound publishing only, is not a jailbreak detector, and is fail-open, and the docs say so plainly.+- **Magpie TTS multilingual** over Riva gRPC gives agents eleven voice personas in nine languages, and Riva ASR handles the microphone.++The mobile app did not change which models we use. It changed how much of the judgment had to move onto the device.++## What the phone does before it touches a GPU++The selfie scanner runs a live 468-point face mesh in the browser, on the phone, using `@mediapipe/tasks-vision` served from our own bundle, before any upload. The shutter does not unlock until a face is found, and the hint line names the single most actionable fix: face the camera straight on, hold steady, too dark, too bright. Every threshold traces in a header comment to a real reconstruction failure mode: the worker's no-face rejection, the 35-degree morph-yaw ceiling, provider blur failures, the dim and backlit band from the robustness benchmark.++Two of those numbers were measured rather than reasoned about. The blur floor was calibrated against six real portraits framed as 720x1280 phone selfies and scored through the module's own math, sharp versus the worker's exact degradation kernels: sharp faces read 22.8 to 39.4, a Gaussian blur at radius `longestEdge/220` reads 10.6 to 15.7, and a radius-10 smear reads 6.3 to 9.4. The floor sits at 12, in the empty band between the populations. And because a blown-out face raises Laplacian response instead of lowering it, neither the blur gate nor the mean-luma gate can see window glare, so the face crop also reports the fraction of pixels pinned to near-white and gates that separately.++The effect on the fleet is direct: a rejected selfie never reaches an L4. On a phone, where the inputs are worst, that gate is worth more than another GPU.++The output side got the same treatment. The draft tier's 12,000-polygon cap and Meshopt compression exist so a GLB loads on a phone in the time a page takes to paint. iOS Quick Look has a practical ceiling around 15 MB and Scene Viewer around 20 MB, so the remesh worker produces a USDZ with the idle animation baked in for Apple's sealed viewer, and the high tier's 200,000-polygon PBR output goes to the desktop, Unity, and Unreal exports where it belongs.++## The apps themselves++All three are shells around the live product, because a WebGL product with 733 same-origin API call sites cannot sensibly be forked into a second codebase. On Android the app is a Trusted Web Activity; on iOS it is a Capacitor container; on desktop it is the installed PWA. The native layer is everything the web cannot do.++On the Seeker, every signature routes to the phone's hardware-isolated Seed Vault through Mobile Wallet Adapter; the private key never enters the app process. The app reads the Seeker Genesis Token, a soulbound Token-2022 asset, to badge verified Seeker owners, and the check fails closed on any RPC error. On every Android phone the share sheet drops a photo straight into the selfie scanner, and a home screen widget shows your agent's day, refreshed by WorkManager about every thirty minutes from a server-rendered PNG, because no widget host on any platform can run WebGL. On iPhone, universal links, the system share sheet, wallet redirects over a custom scheme, haptics, and real camera and motion prompts wrap the same product.++The GPU fleet does not know or care which of the three it is serving. That is the point of the architecture.++## Why 3D, why AR, why on-chain++Three short answers, because a forum post about GPUs should still say what the GPUs are for.++3D because humans experience presence through faces and posture, not text, and a rigged character with fifty-two blendshapes that looks at you carries more social information than any chat bubble. AR because a character standing on your floor casting a shadow is a presence, and a character on a screen is a picture; WebXR is the mode where the agent stays alive, with microphone, chat, and gaze tracking the camera, and it is a phone-only capability. On-chain because an agent that lives in one vendor's dashboard cannot be verified at a distance, cannot outlive the vendor, and cannot pay for its own inference; a public ledger gives it an identity, an owner, a wallet, and a signed history, and HTTP 402 gives it a way to pay per call in stablecoin with no human in the loop. The GPU fleet is a paid x402 endpoint too: rigging is $0.05 a call, and any agent with a wallet can buy a stage of the pipeline without an account.++## The platform in numbers++From the first commit in April to the end of August: 761 public pages, more than 2,700 changelog entries at roughly twenty shipped changes a day, 101 npm packages, 72 MCP servers in the official registry, 33 workers, 1,752 test files, more than 3,000 motion-capture clips and 106 rigged characters in the library, and a machine-payment rail that has settled over 110,000 calls on-chain. All Apache-2.0.++## What Inception adds, and what we are building next++Membership in NVIDIA Inception is a startup programme, not a partnership or an endorsement, and I say so every time. What it adds is exactly the constraint above: GPU capacity, which is the single hardest limit on how fast and how detailed generation can be, plus the technical guidance we are using for the next stage.++That stage, in order:++- **NVIDIA ACE.** Audio2Face-3D for facial animation driven by the agent's own speech, and Riva for the full speech loop, replacing the browser-side lip-sync with a GPU-side one.+- **Self-hosted NIM and TensorRT-LLM.** The hosted lane is free and rate-limited with no SLA, which is why every consumer keeps a fallback behind it. Bringing the Nemotron lane onto our own fleet is how the free-first design scales past the free tier.+- **Omniverse and OpenUSD.** Every character already exports to USDZ for Quick Look; a real OpenUSD interop path makes the library useful outside the browser.+- **iOS and macOS widgets, push, and the likeness track.** The selfie engine is wired end to end; fidelity is the open research problem, and it is the one that matters most.++If you are serving generative 3D to phones, the two things I would tell you first: put the judgment in front of the GPU, on the device if you can; and treat regional warm pins as a resource you are taking from the lane that region actually serves. Everything else is in the repo.++[github.com/nirholas/three.ws](https://github.com/nirholas/three.ws)++#NVIDIAInception