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
fix(seed-cron): only rig the meshes a humanoid skeleton can actually drive
nirholas9bd72e348ea4
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 4e3f0a21c..3ae11352e 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -23,7 +23,7 @@ Public history for [three.ws](https://three.ws), newest first. New pages come fr- **Fact-check now reads the part of a source that is actually about your claim**: When the fact-checker fell back to Wikipedia, it only ever read each article's opening summary. An opening summary says what a page is about, so it carries the answer only when your claim is about the page's subject. Ask whether Napoleon was unusually short and it read the first lines of "Napoleon", "Napoleon III" and "Napoleonic Wars", none of which mention height at all, so every source was scored as saying nothing and the verdict came back "not enough evidence" while the passage about his height sat further down the same article. The checker now reads each article in full and picks the paragraphs that actually discuss your claim, so that question returns the "Appearance and image" and "Napoleon's height" sections instead. Reference lists are skipped, since they repeat your words without asserting anything, and the deeper read is bounded by the time the check already had, so a slow source can never cost you the evidence that already arrived. (`/docs/fact-check`) `[improvement]`- **Fade Radar: the wallets that have never once been right, and the coins they are crowding into**: The Smart Money Radar tells you which proven winners are buying a coin. Fade Radar is the other half of that question, and on pump.fun it turns out to be the sharper one: how much of a coin's buy side is money that has never been right. A wallet joins the reverse-indicator board only after five coins it bought have a known outcome and not one of them won, which is a bar a surprising number of addresses clear. The new page ranks every launch from the last few hours by how much of its observed buy side belongs to those wallets, by wallet count and by SOL, and carries a second board of the wallets themselves with their full record. The number above the board is the part we care most about: it is measured, not asserted. We rebuild the reverse-indicator group using only coins whose outcome was known before the coins it is graded on existed, then check what actually happened. Coins where a quarter or more of the buyers were reverse indicators went on to win 1.8 percent of the time, against 22.1 percent for coins with none, across 26,626 labelled coins. Nothing here is a short and nothing signs anything: on a bonding curve the only tradeable form of a fade is not buying, so every action on the page is a link out to the coin, its intel, or a wallet's track record. Wallet links also now open directly on the Smart Money Radar, so an address cited anywhere on the platform lands on its record instead of a board you have to scan by eye. (`/fade`) `[feature]`- **Homes connected through the relay now follow the house when you rearrange it**: If your Home Assistant is only reachable inside your house, three.ws reaches it through the three.ws integration you install there, which dials out to us. Those homes were building their room list once, when the connection opened, and then quietly ignoring changes: assign a lamp to the kitchen, rename a floor, add a device, and the 3D house kept showing the old arrangement until the connection happened to be rebuilt. Homes connected by a direct address never had this problem, and the split was in the relay, which was not carrying the four small notices Home Assistant sends when its rooms, floors, devices or entities change. It carries them now, so both kinds of connection track the house the same way and updates land in seconds. The notices only say that something changed; the relay already read the full room and floor lists, so nothing new about your house is exposed by this. (`/smart-home`) `[fix, infra]`-- **New gallery avatars now arrive with a skeleton, so they animate properly out of the box**: Avatars generated for the gallery were published as static meshes: they still moved, but through a fallback that maps a generic body onto them rather than a skeleton of their own. Every new one now goes through our auto-rigger first and arrives with a real 52-bone humanoid skeleton, which means the whole motion library drives it directly. If the rigger fails or stalls, the avatar is still published rather than held back, so nothing is lost to a bad rig. (`/gallery`) `[improvement, feature]`+- **New gallery avatars now arrive with a skeleton, so they animate properly out of the box**: Avatars generated for the gallery were published as static meshes: they still moved, but through a fallback that maps a generic body onto them rather than a skeleton of their own. Every new one whose shape a humanoid skeleton can actually drive now goes through our auto-rigger first and arrives with a real 52-bone skeleton, so the whole motion library drives it directly. The ones that are skipped are skipped for a reason we measured: some generated models come out as a figure standing on a wide base slab, and rigging one of those tears the slab apart the moment it moves, so those keep publishing as static models. If the rigger fails or stalls, the avatar is published anyway rather than held back. (`/gallery`) `[improvement, feature]`- **News cards stop losing their preview picture to a cold cache**: About a fifth of the crypto-news feed ships text-only, so those cards start as a source tile and upgrade in place once the publisher's own preview image is found. That lookup searched all 197 publisher feeds at once and gave up after 2.5 seconds, which on a freshly started server dropped whichever feed had not answered yet, so an article the feed had just served came back as unknown. The reader kept its tile, but the failed lookup was recorded as a public answer for the next ten minutes, so every visitor to /markets and /markets/news got the same dead result and a 404 in their browser console. The lookup now asks the one publisher that could hold the article first and waits for it, and a result that could not be confirmed is held for 30 seconds instead of ten minutes. (`/markets/news`) `[fix]`- **Oracle: a failed request now says so, instead of claiming no coins have been scored**: A full audit of /oracle, the fused conviction board for pump.fun launches. When a panel's request failed, the page told you the opposite of the truth: the live feed claimed "Oracle is warming up" and said the engine ships with its backend, the movers, proof, agent-ranking, activity and 3D-graph panels each claimed there was simply nothing to show, and the performance record said the edge was still proving itself. Every one of those is now a real error state that names what went wrong (offline, rate limited, or an engine error) and offers a retry that actually recovers. The Proof gallery had a second bug behind that one: opening it for the first time while the request failed painted nothing at all, not even a skeleton. Searching a symbol Oracle has not scored used to make the results dropdown vanish with no explanation, which reads as a broken search box; it now says there is no match, and says so differently when search itself is down. The conviction-breadth bar's tier segments and legend chips were 10 and 15 pixels tall, too small to reliably tap on a phone, and now carry a full 24-pixel target without changing how the bar looks. Screen readers can finally move from a tab into the panel it opens, every button declares its type, and if a browser is holding a cached copy of an older release the 3D graph explains that and offers a reload instead of retrying a module that can never load. (`/oracle`) `[fix, improvement]`- **Paid 3D services now refuse a job they cannot deliver, instead of charging for it**: The paid three.ws forge services sold to other AI agents charge the moment the generator accepts a job, and the finished model reaches the buyer only after it lands in our delivery storage. When that storage stopped accepting writes, jobs were still being accepted and charged while no model could ever be handed back. Those services now check that delivery storage is writable before they take the job: if it is not, the call is refused, says so, and is not charged. The check is cached and ignores a one-off blip, so a passing wobble never stops the services selling. The free public health page also had a bug where a storage failure replaced the name of the failing subsystem with the storage provider's error code and printed the request's signing details; it now names the subsystem and reports the reason alone. `[fix, security]`diff --git a/api/cron/forge-seed-cron.js b/api/cron/forge-seed-cron.jsindex e8ec4c4b8..000ac384c 100644--- a/api/cron/forge-seed-cron.js+++ b/api/cron/forge-seed-cron.js@@ -54,9 +54,10 @@// publishing, so catalog entries arrive animation-ready// instead of driven by the retarget fallback. ON by// default since 2026-09-09; set it to '0' to publish-// static meshes again. A rig fault, or a rig that stops-// answering (RIG_STALL_MS), publishes the gated keeper-// static rather than losing it.+// static meshes again. Only meshes a humanoid rig can+// drive are sent (riggableShape); a rig fault, or a rig+// that stops answering (RIG_STALL_MS), publishes the+// gated keeper static rather than losing it.import { json, method, wrapCron } from '../_lib/http.js';import { env } from '../_lib/env.js';@@ -123,6 +124,38 @@ const visionGateBudgetMs = () => intEnv('SEED_CRON_VISION_MS', 20_000, { min: 5_// the worst case of leaving it on is the asset the old default always shipped.// Set SEED_CRON_RIG=0 to go back to publishing static meshes.export const rigStageEnabled = () => boolEnv('SEED_CRON_RIG', true);++/**+ * Can a humanoid skeleton drive this mesh at all?+ *+ * The gate asks whether an asset is worth publishing. This asks a different+ * question: whether binding a humanoid rig to it makes it better or worse. It+ * can make it much worse. A text-to-3D lane routinely returns a figure standing+ * on a wide base slab, and the auto-rigger skins the slab along with the+ * figure, so the first clip that moves the legs tears the slab across the+ * scene. Measured on the real thing: a seeded "sky pirate" mesh (1.99 x 0.69 x+ * 1.99) rigged cleanly by every structural measure (52-joint mixamorig+ * skeleton, unit inverse binds) and then shredded on screen the moment the idle+ * clip played, while the same mesh published static rendered correctly.+ *+ * `thinAxis` is the signal, and the gate already stores it: glTF is Y-up, so a+ * mesh whose THINNEST extent is Y is lying down or sitting in a slab, while an+ * upright figure is always thinnest front-to-back or side-to-side. Over a+ * 12-mesh sample of what the cron actually published, the ten proper humanoids+ * ran 1.47 to 2.63 in height over width and none was thin in Y; the two that+ * were (the pirate, a rearing horse statuette) are exactly the two that must+ * not be rigged. `planar` catches the other end, a mesh with no depth at all.+ *+ * A mesh that fails this is published static, which is what every seed avatar+ * before 2026-09-09 was anyway.+ *+ * @param {{ thinAxis?: string | null, planar?: boolean } | null | undefined} metrics+ */+export function riggableShape(metrics) {+ if (!metrics) return true; // no measurement is not evidence against rigging+ if (metrics.planar === true) return false;+ return metrics.thinAxis !== 'y';+}// A rig job that never answers must not hold a row forever. advanceRigs polls// the ten oldest 'rigging' rows per tick, so a permanently stuck row would sit// at the front of that queue and starve the ones behind it. Past this age the@@ -444,9 +477,15 @@ async function advanceGates(origin) {continue;}- // A keeper. Rig first when the stage is on and the mesh is not already- // skinned; otherwise publish straight away.- if (rigStageEnabled() && !verdict.mesh.rigged && job.model_category !== 'accessory') {+ // A keeper. Rig first when the stage is on, the mesh is not already+ // skinned, and its shape is one a humanoid rig can actually drive;+ // otherwise publish straight away.+ if (+ rigStageEnabled()+ && !verdict.mesh.rigged+ && job.model_category !== 'accessory'+ && riggableShape(verdict.mesh?.metrics)+ ) {const rig = await startRigStage({ origin, job });if (rig.jobId) {await sql`diff --git a/data/changelog.json b/data/changelog.jsonindex 43886db78..7117c31d5 100644--- a/data/changelog.json+++ b/data/changelog.json@@ -4,7 +4,7 @@{"date": "2026-09-09","title": "New gallery avatars now arrive with a skeleton, so they animate properly out of the box",- "summary": "Avatars generated for the gallery were published as static meshes: they still moved, but through a fallback that maps a generic body onto them rather than a skeleton of their own. Every new one now goes through our auto-rigger first and arrives with a real 52-bone humanoid skeleton, which means the whole motion library drives it directly. If the rigger fails or stalls, the avatar is still published rather than held back, so nothing is lost to a bad rig.",+ "summary": "Avatars generated for the gallery were published as static meshes: they still moved, but through a fallback that maps a generic body onto them rather than a skeleton of their own. Every new one whose shape a humanoid skeleton can actually drive now goes through our auto-rigger first and arrives with a real 52-bone skeleton, so the whole motion library drives it directly. The ones that are skipped are skipped for a reason we measured: some generated models come out as a figure standing on a wide base slab, and rigging one of those tears the slab apart the moment it moves, so those keep publishing as static models. If the rigger fails or stalls, the avatar is published anyway rather than held back.","tags": ["improvement","feature"diff --git a/docs/ops/gcp-credits.md b/docs/ops/gcp-credits.mdindex 1d19e246b..05c73146d 100644--- a/docs/ops/gcp-credits.md+++ b/docs/ops/gcp-credits.md@@ -1780,6 +1780,27 @@ minutes, added in the same change because `advanceRigs` polls the ten oldestrigging rows and a permanently stuck row would starve the queue behind it). Set`SEED_CRON_RIG=0` to go back to static meshes.+**Not every mesh may be rigged, and that limit is measured rather than assumed.**+The first mesh taken through the lane end to end, a seeded sky pirate, produced a+structurally perfect rig (52 joints, unit inverse binds) and then shredded on+screen the moment the curated `idle` clip played, while the same mesh published+static rendered correctly. The cause is not the rigger: the generated mesh is a+figure sitting in a wide base slab (1.99 x 0.69 x 1.99), the rigger skins the+slab along with the figure, and the first clip that moves the legs drags it+across the scene. `riggableShape()` refuses that shape before the submit, using+the `thinAxis` the gate already records: glTF is Y-up, so a mesh thinnest in Y is+lying down or slab-bound, while an upright figure is always thinnest front-to-back+or side-to-side. Over a 12-mesh sample of live cron output the ten proper+humanoids ran 1.47 to 2.63 in height over width with no Y-thin mesh among them,+and the two Y-thin ones (the pirate, a rearing horse statuette) are exactly the+two that must not be rigged. Roughly one seeded mesh in six is therefore+published static, which is what all of them were before.++That sample turned up a second catalog-quality problem worth its own pass: one+published mesh measured 1.99 x 1.99 x 0.01, a flat billboard rather than a model.+The gate's `planar` rule is what should have caught it, and did not, because at+`thinAxis: 'z'` it is held to the sliver threshold rather than the slab one.+Both stages, and the accept rate they produce, are now measurable from`forge_seed_jobs` alone: since 2026-09-09 the cron records the full verdict onthe keepers as well as the rejects (`publishSeedAvatar`, covered bydiff --git a/public/changelog-recent.json b/public/changelog-recent.jsonindex d8057b8d2..0ec70d83a 100644--- a/public/changelog-recent.json+++ b/public/changelog-recent.json@@ -1,5 +1,5 @@{- "generated_at": "2026-09-09T20:16:32.324Z",+ "generated_at": "2026-09-09T20:27:30.345Z","generated_by": "scripts/build-page-index.mjs from data/pages.json + data/changelog.json","site": {"name": "three.ws",@@ -191,7 +191,7 @@"date": "2026-09-09","type": "update","title": "New gallery avatars now arrive with a skeleton, so they animate properly out of the box",- "summary": "Avatars generated for the gallery were published as static meshes: they still moved, but through a fallback that maps a generic body onto them rather than a skeleton of their own. Every new one now goes through our auto-rigger first and arrives with a real 52-bone humanoid skeleton, which means the whole motion library drives it directly. If the rigger fails or stalls, the avatar is still published rather than held back, so nothing is lost to a bad rig.",+ "summary": "Avatars generated for the gallery were published as static meshes: they still moved, but through a fallback that maps a generic body onto them rather than a skeleton of their own. Every new one whose shape a humanoid skeleton can actually drive now goes through our auto-rigger first and arrives with a real 52-bone skeleton, so the whole motion library drives it directly. The ones that are skipped are skipped for a reason we measured: some generated models come out as a figure standing on a wide base slab, and rigging one of those tears the slab apart the moment it moves, so those keep publishing as static models. If the rigger fails or stalls, the avatar is published anyway rather than held back.","link": "/gallery","tags": ["improvement",diff --git a/public/changelog.json b/public/changelog.jsonindex e92bf1858..29246649d 100644--- a/public/changelog.json+++ b/public/changelog.json@@ -1,5 +1,5 @@{- "generated_at": "2026-09-09T20:16:32.285Z",+ "generated_at": "2026-09-09T20:27:30.268Z","generated_by": "scripts/build-page-index.mjs from data/pages.json + data/changelog.json","site": {"name": "three.ws",@@ -188,7 +188,7 @@"date": "2026-09-09","type": "update","title": "New gallery avatars now arrive with a skeleton, so they animate properly out of the box",- "summary": "Avatars generated for the gallery were published as static meshes: they still moved, but through a fallback that maps a generic body onto them rather than a skeleton of their own. Every new one now goes through our auto-rigger first and arrives with a real 52-bone humanoid skeleton, which means the whole motion library drives it directly. If the rigger fails or stalls, the avatar is still published rather than held back, so nothing is lost to a bad rig.",+ "summary": "Avatars generated for the gallery were published as static meshes: they still moved, but through a fallback that maps a generic body onto them rather than a skeleton of their own. Every new one whose shape a humanoid skeleton can actually drive now goes through our auto-rigger first and arrives with a real 52-bone skeleton, so the whole motion library drives it directly. The ones that are skipped are skipped for a reason we measured: some generated models come out as a figure standing on a wide base slab, and rigging one of those tears the slab apart the moment it moves, so those keep publishing as static models. If the rigger fails or stalls, the avatar is published anyway rather than held back.","link": "/gallery","tags": ["improvement",diff --git a/public/changelog.xml b/public/changelog.xmlindex 357ef09b3..3fc4f9de0 100644--- a/public/changelog.xml+++ b/public/changelog.xml@@ -148,7 +148,7 @@<guid isPermaLink="false">2026-09-09:New gallery avatars now arrive with a skeleton, so they animate properly out of the box</guid><pubDate>Wed, 09 Sep 2026 12:00:00 GMT</pubDate><category>improvement</category>- <description>Avatars generated for the gallery were published as static meshes: they still moved, but through a fallback that maps a generic body onto them rather than a skeleton of their own. Every new one now goes through our auto-rigger first and arrives with a real 52-bone humanoid skeleton, which means the whole motion library drives it directly. If the rigger fails or stalls, the avatar is still published rather than held back, so nothing is lost to a bad rig.</description>+ <description>Avatars generated for the gallery were published as static meshes: they still moved, but through a fallback that maps a generic body onto them rather than a skeleton of their own. Every new one whose shape a humanoid skeleton can actually drive now goes through our auto-rigger first and arrives with a real 52-bone skeleton, so the whole motion library drives it directly. The ones that are skipped are skipped for a reason we measured: some generated models come out as a figure standing on a wide base slab, and rigging one of those tears the slab apart the moment it moves, so those keep publishing as static models. If the rigger fails or stalls, the avatar is published anyway rather than held back.</description></item><item><title>News cards stop losing their preview picture to a cold cache</title>diff --git a/tests/cron-seed-gate-record.test.js b/tests/cron-seed-gate-record.test.jsindex 90bb232d7..e8792b4d0 100644--- a/tests/cron-seed-gate-record.test.js+++ b/tests/cron-seed-gate-record.test.js@@ -27,7 +27,7 @@ vi.mock('../api/_lib/db.js', () => ({},}));-const { publishSeedAvatar, rigStageEnabled } = await import('../api/cron/forge-seed-cron.js');+const { publishSeedAvatar, rigStageEnabled, riggableShape } = await import('../api/cron/forge-seed-cron.js');const JOB = {id: 'job-1',@@ -118,3 +118,34 @@ describe('rigStageEnabled', () => {expect(rigStageEnabled()).toBe(true);});});++// Which meshes may be rigged at all. Every number here is measured off real+// seeded output, not chosen: the ten proper humanoids in a 12-mesh sample were+// all thinnest front-to-back or side-to-side, and the two that were thinnest in+// Y are the two an auto-rig destroys, because the rigger skins the base slab+// along with the figure and the first clip that moves the legs tears it across+// the scene.+describe('riggableShape', () => {+ it('rigs an upright figure, thin front-to-back', () => {+ expect(riggableShape({ thinAxis: 'z', flatness: 0.3, planar: false })).toBe(true);+ });++ it('rigs an upright figure, thin side-to-side', () => {+ expect(riggableShape({ thinAxis: 'x', flatness: 0.19, planar: false })).toBe(true);+ });++ it('refuses a figure sitting in a base slab', () => {+ // The measured sky pirate: 1.99 x 0.69 x 1.99, rigged perfectly and+ // shredded on screen.+ expect(riggableShape({ thinAxis: 'y', flatness: 0.35, planar: false })).toBe(false);+ });++ it('refuses a mesh with no depth at all', () => {+ expect(riggableShape({ thinAxis: 'z', flatness: 0.005, planar: true })).toBe(false);+ });++ it('rigs when the mesh was never measured, rather than refusing on no evidence', () => {+ expect(riggableShape(null)).toBe(true);+ expect(riggableShape({})).toBe(true);+ });+});