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(vision): reserve the lane floor instead of dividing the deadline equally
nirholas8b095e112f1d
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 3282f82e7..bfdbce118 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -8,6 +8,7 @@ Public history for [three.ws](https://three.ws), newest first. New pages come fr- **3D assets now load on any website, not just ours**: Files served straight from our asset storage carried a permission list that only named a handful of sites, so a browser on any other site quietly threw the file away after downloading it. Anyone embedding a three.ws avatar or model from its direct storage link saw an empty viewer with a cross-origin error, and the workarounds were our /cdn and /api/glb routes. Storage now allows reads from everywhere while keeping uploads locked to our own pages, so direct links work in any embed. This also fixed a first-party case: the www version of the site served every page correctly but had all of its 3D blocked. `[fix, infra]`- **A smart home that stops answering now says so, instead of reading Live**: If your house went offline while three.ws already had a connection open to it, the home card could keep showing Live, updated moments ago for as long as you watched. The live 3D scene knew and went stale correctly, but the stored status did not, so anything reading it (the card, the home list, a wall display) kept describing a house that was gone as healthy. A house dropping out is now recorded the moment it is noticed, and recorded again when it comes back, so every surface agrees. This was invisible on a first visit and permanent on a busy one, which is why it survived so long. (`/smart-home`) `[fix]`+- **Adding more AI providers no longer makes the image check slower to answer**: The image check behind generated models asks several providers in turn, and it shared its time limit out equally between all of them. That had a perverse effect: every provider added to the list shortened the time given to the first and best one, so growing the list made the check worse rather than more resilient. Three providers were added last week and the first one's window fell just below what it needs to answer, which is why the check started timing out instead of returning verdicts. Each provider is now given whatever time the ones behind it do not need, with a guaranteed minimum still held back for every one of them, so the check gets a real answer from the first healthy provider and still falls through to the rest when it has to. `[fix, improvement]`- **Generated motion clips rebuilt so they no longer slide across the floor**: The generated half of the animation library was written in the wrong rest pose and carried a constant forward drift that was never in the original motion, which made characters glide instead of plant their feet. Every published clip was re-derived from the motion already generated, re-checked against the quality gate, and republished: 39 clips that now pass are live, and the 94 that still failed on foot-sliding were withdrawn rather than left on the shelf. No new generation was needed, because the motion was correct all along and only written down wrong. (`/animations`) `[fix, improvement]`- **Repaired the free AI lanes, which had been quietly answering nothing**: Several of the free AI models the platform falls back to had been retired by their provider and were answering every request with a Gone error. Nothing logged it as a problem, because a dead model looks the same as a busy one to a fallback chain: it just moves on. The cost was real though, since each dead entry ate one of the limited retry slots that should have gone to a lane that could actually answer, making the whole chain fail sooner and more often under load. Every model id is now checked against the provider's live catalog, the dead ones are replaced with working models, and the same applies to the search-and-memory embedding lane, which had been failing for two weeks. Older stored memories keep working: they are tagged with the model that created them and still resolve. `[fix, infra]`- **The image check now moves on when a model answers in the wrong format**: Generated models are inspected by a vision model before you see them, and that inspection asks several providers in turn so one being busy is never the end of it. The catch was that a provider only had to reply, not reply usefully: a model that narrated its thinking instead of returning the requested format counted as the answer, and the healthy providers waiting behind it were never asked. A reply the check cannot read is now treated as that provider failing, so it moves straight to the next one, and it only gives up once every provider has been tried. The practical effect is that the quality check returns a real verdict far more often, and when it cannot, the reason it reports names the provider that actually lost. `[fix, improvement]`diff --git a/api/_lib/vision.js b/api/_lib/vision.jsindex 66706dd09..6c3c96995 100644--- a/api/_lib/vision.js+++ b/api/_lib/vision.js@@ -162,7 +162,25 @@ function coolLane(chain, lane, { seconds, reason, hostWide }) {*/export function laneAttemptTimeout(remainingMs, lanesLeft, timeoutMs) {if (!Number.isFinite(remainingMs)) return timeoutMs;- const share = remainingMs / Math.max(1, lanesLeft);+ // Reserve the floor for the rungs behind this one, then give this lane the+ // rest. It used to divide the budget EQUALLY, which quietly punishes the+ // chain for having depth: every lane added to the list shrinks the slice the+ // FIRST and best lane gets, even though that lane is the one most likely to+ // answer. Adding three OpenRouter rungs on 2026-09-09 took the free NIM+ // lane's slice from about 9.7s to about 4.8s against the forge quality+ // gate's 29s deadline, which is just under what it needs for the scoring+ // rubric, and the gate went from 5 verdicts in 10 to 0 in 10 (measured on+ // production 2026-09-10). Nothing about either lane changed; the arithmetic+ // did.+ //+ // Reserving instead of dividing keeps the property the split existed for (a+ // hung lane cannot eat the whole deadline, and every remaining rung is still+ // guaranteed MIN_LANE_ATTEMPT_MS) while letting the lane in hand use the+ // budget nobody else needs yet. A lane that fails fast hands its unused+ // share straight to the next one, because `remainingMs` is re-read per+ // attempt.+ const reserve = MIN_LANE_ATTEMPT_MS * Math.max(0, lanesLeft - 1);+ const share = Math.max(MIN_LANE_ATTEMPT_MS, remainingMs - reserve);// The floor may exceed the share when the budget is nearly spent; capping it// by what is actually left keeps the attempt inside the deadline either way.//diff --git a/data/changelog.json b/data/changelog.jsonindex 6b0e3b104..219389911 100644--- a/data/changelog.json+++ b/data/changelog.json@@ -28070,6 +28070,15 @@"fix","improvement"]+ },+ {+ "date": "2026-09-10",+ "title": "Adding more AI providers no longer makes the image check slower to answer",+ "summary": "The image check behind generated models asks several providers in turn, and it shared its time limit out equally between all of them. That had a perverse effect: every provider added to the list shortened the time given to the first and best one, so growing the list made the check worse rather than more resilient. Three providers were added last week and the first one's window fell just below what it needs to answer, which is why the check started timing out instead of returning verdicts. Each provider is now given whatever time the ones behind it do not need, with a guaranteed minimum still held back for every one of them, so the check gets a real answer from the first healthy provider and still falls through to the rest when it has to.",+ "tags": [+ "fix",+ "improvement"+ ]}]}diff --git a/public/changelog-recent.json b/public/changelog-recent.jsonindex a63dc637c..a808c5ac0 100644--- a/public/changelog-recent.json+++ b/public/changelog-recent.json@@ -1,11 +1,11 @@{- "generated_at": "2026-09-10T15:20:36.348Z",+ "generated_at": "2026-09-10T15:26:08.096Z","generated_by": "scripts/build-page-index.mjs from data/pages.json + data/changelog.json","site": {"name": "three.ws","url": "https://three.ws"},- "total": 3664,+ "total": 3665,"complete": false,"full_feed": "/changelog.json","entries": [@@ -30,6 +30,17 @@"fix"]},+ {+ "date": "2026-09-10",+ "type": "update",+ "title": "Adding more AI providers no longer makes the image check slower to answer",+ "summary": "The image check behind generated models asks several providers in turn, and it shared its time limit out equally between all of them. That had a perverse effect: every provider added to the list shortened the time given to the first and best one, so growing the list made the check worse rather than more resilient. Three providers were added last week and the first one's window fell just below what it needs to answer, which is why the check started timing out instead of returning verdicts. Each provider is now given whatever time the ones behind it do not need, with a guaranteed minimum still held back for every one of them, so the check gets a real answer from the first healthy provider and still falls through to the rest when it has to.",+ "link": null,+ "tags": [+ "fix",+ "improvement"+ ]+ },{"date": "2026-09-10","type": "update",@@ -1606,17 +1617,6 @@"improvement","feature"]- },- {- "date": "2026-09-07",- "type": "update",- "title": "Turn a photo into a 3D model without leaving your editor",- "summary": "The Blender tools could already build a model from a written description. They now build one from a picture too: point at an image on your machine or a link to one, add a few words to steer it if you like, and the finished model opens in Blender. It runs on the same free lane as the text version and takes about as long.",- "link": null,- "tags": [- "feature",- "sdk"- ]}]}diff --git a/public/changelog.json b/public/changelog.jsonindex 9327665a0..0cbb72ac7 100644--- a/public/changelog.json+++ b/public/changelog.json@@ -1,5 +1,5 @@{- "generated_at": "2026-09-10T15:20:36.328Z",+ "generated_at": "2026-09-10T15:26:08.075Z","generated_by": "scripts/build-page-index.mjs from data/pages.json + data/changelog.json","site": {"name": "three.ws",@@ -27,6 +27,17 @@"fix"]},+ {+ "date": "2026-09-10",+ "type": "update",+ "title": "Adding more AI providers no longer makes the image check slower to answer",+ "summary": "The image check behind generated models asks several providers in turn, and it shared its time limit out equally between all of them. That had a perverse effect: every provider added to the list shortened the time given to the first and best one, so growing the list made the check worse rather than more resilient. Three providers were added last week and the first one's window fell just below what it needs to answer, which is why the check started timing out instead of returning verdicts. Each provider is now given whatever time the ones behind it do not need, with a guaranteed minimum still held back for every one of them, so the check gets a real answer from the first healthy provider and still falls through to the rest when it has to.",+ "link": null,+ "tags": [+ "fix",+ "improvement"+ ]+ },{"date": "2026-09-10","type": "update",diff --git a/public/changelog.xml b/public/changelog.xmlindex 4276ba77d..b9323c1a5 100644--- a/public/changelog.xml+++ b/public/changelog.xml@@ -22,6 +22,14 @@<category>fix</category><description>If your house went offline while three.ws already had a connection open to it, the home card could keep showing Live, updated moments ago for as long as you watched. The live 3D scene knew and went stale correctly, but the stored status did not, so anything reading it (the card, the home list, a wall display) kept describing a house that was gone as healthy. A house dropping out is now recorded the moment it is noticed, and recorded again when it comes back, so every surface agrees. This was invisible on a first visit and permanent on a busy one, which is why it survived so long.</description></item>+ <item>+ <title>Adding more AI providers no longer makes the image check slower to answer</title>+ <link>https://three.ws/changelog</link>+ <guid isPermaLink="false">2026-09-10:Adding more AI providers no longer makes the image check slower to answer</guid>+ <pubDate>Thu, 10 Sep 2026 12:00:00 GMT</pubDate>+ <category>fix</category>+ <description>The image check behind generated models asks several providers in turn, and it shared its time limit out equally between all of them. That had a perverse effect: every provider added to the list shortened the time given to the first and best one, so growing the list made the check worse rather than more resilient. Three providers were added last week and the first one's window fell just below what it needs to answer, which is why the check started timing out instead of returning verdicts. Each provider is now given whatever time the ones behind it do not need, with a guaranteed minimum still held back for every one of them, so the check gets a real answer from the first healthy provider and still falls through to the rest when it has to.</description>+ </item><item><title>Generated motion clips rebuilt so they no longer slide across the floor</title><link>https://three.ws/animations</link>diff --git a/public/features.json b/public/features.jsonindex dea6115ba..b9d678978 100644--- a/public/features.json+++ b/public/features.json@@ -1,5 +1,5 @@{- "generated_at": "2026-09-10T15:20:36.317Z",+ "generated_at": "2026-09-10T15:26:08.064Z","generated_by": "scripts/build-page-index.mjs from data/pages.json","site": {"name": "three.ws",diff --git a/tests/api/vision-lane-health.test.js b/tests/api/vision-lane-health.test.jsindex 6867b47df..e09d27509 100644--- a/tests/api/vision-lane-health.test.js+++ b/tests/api/vision-lane-health.test.js@@ -57,10 +57,37 @@ afterEach(async () => {});describe('laneAttemptTimeout', () => {- it('splits the remaining deadline across the lanes still to come', () => {- // 18s left, three lanes to go: 6s each, so the last rung still gets a turn.- expect(laneAttemptTimeout(18_000, 3, 20_000)).toBe(6_000);- expect(laneAttemptTimeout(12_000, 2, 20_000)).toBe(6_000);+ it('reserves the floor for the rungs behind, and gives this lane the rest', () => {+ // 18s left, three lanes to go: hold 3.5s for each of the two behind and+ // hand this one the remaining 11s. Dividing equally (6s each) starved the+ // best lane for the benefit of rungs that may never be reached.+ expect(laneAttemptTimeout(18_000, 3, 20_000)).toBe(11_000);+ expect(laneAttemptTimeout(12_000, 2, 20_000)).toBe(8_500);+ });+ it('still guarantees every remaining rung its floor', () => {+ // Walk the chain the way describeImage does, spending each slice in full.+ let remaining = 18_000;+ const slices = [];+ for (let lanesLeft = 3; lanesLeft > 0; lanesLeft--) {+ const ms = laneAttemptTimeout(remaining, lanesLeft, 20_000);+ slices.push(ms);+ remaining -= ms;+ }+ expect(slices).toEqual([11_000, 3_500, 3_500]);+ expect(remaining).toBe(0);+ for (const ms of slices) expect(ms).toBeGreaterThanOrEqual(3_500);+ });+ it('does not shrink the first lane as the chain grows', () => {+ // The regression that took the forge quality gate to 0 verdicts in 10.+ // Its deadline is 29s and the chain went from 3 lanes to 6 when the+ // OpenRouter rungs landed; under equal division the free NIM lane's slice+ // fell from ~9.7s to ~4.8s, just under what the scoring rubric needs.+ const sixLanes = laneAttemptTimeout(29_000, 6, 25_000);+ const equalDivision = Math.floor(29_000 / 6); // 4_833, the old policy+ expect(sixLanes).toBe(11_500);+ expect(sixLanes).toBeGreaterThan(equalDivision * 2);+ // Deep chains still leave the first lane more than a single VLM call needs.+ expect(laneAttemptTimeout(29_000, 8, 25_000)).toBeGreaterThan(4_000);});it('never exceeds the caller timeout and never outlives the deadline', () => {expect(laneAttemptTimeout(60_000, 1, 20_000)).toBe(20_000);@@ -81,7 +108,7 @@ describe('laneAttemptTimeout', () => {// fallback rung. 23_474/3 is the shape production actually produced.const split = laneAttemptTimeout(23_474, 3, 20_000);expect(Number.isInteger(split)).toBe(true);- expect(split).toBe(7_824);+ expect(split).toBe(16_474);expect(() => AbortSignal.timeout(split)).not.toThrow();for (const remaining of [23_474, 9_999, 12_345, 7_001]) {for (const lanes of [1, 2, 3, 4, 7]) {