Skip to content

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.

docs(crawl): document the Crawl for watchers, owners and API users, and register its pages

nirholas385f9ac9f93c
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0a6250bdc..aeefd4bc1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,8 +10,14 @@ Public history for [three.ws](https://three.ws), newest first. New pages come fr
- **Claim your X creations** (`/x/claim`): Models and avatars the three.ws bot made for you on X wait here. Link the same X account and every one of them moves into your library.
- **Docs · CAD Forge (text to parametric CAD)** (`/docs/cad-forge`): How a sentence becomes a kernel-checked build123d part: the write, build and repair loop, dimension parameters, the design page, the /api/cad HTTP API, the cad_generate and cad_rebuild MCP tools, and the sandbox that runs model-written code.
- **Docs · Grok Bot connector reference** (`/docs/grok-bot`): Exact connector settings for Grok Bot, which sign-in and which server to pick, the links, jobs, retry and rate-limit contracts for unattended runs, the spend rule, and a fix for every failure the connector probe can report.
+- **Docs · Modly and three.ws** (`/docs/modly`): Every way three.ws works with Modly, the free open-source 3D app: generate on your own GPU from /modly or the Forge, add three.ws cloud nodes and publishing to Modly, the desktop app, and the mesh tools and slicer handoff built from Modly ideas.
+- **Docs · three.ws Forge for desktop** (`/docs/forge-desktop`): How to install and use three.ws Forge, the desktop 3D studio: run it from source or an installer, generate on your own GPU or the three.ws cloud, build node workflows, import CC0 models, sign in and publish to three.ws, and fix common setup problems.
+- **Docs · Workbench** (`/docs/workbench`): How the Workbench runs a photo through an editable workflow of real GPU nodes, edits the result in the viewport, exports GLB, OBJ, STL or PLY, and how scripts call the same pipeline.
+- **Forge Workflows: Chain 3D Tools into One Run** (`/forge/workflows`): A visual workflow builder for the Forge. Link a prompt or a photo to any live 3D engine, then remesh, rig, segment, restyle or make it game-ready, preview it inline, export the GLB and save it to your library, all in one run. Batch many prompts with ForEach, re-run from a failed step without redoing the rest, or generate on your own GPU with Modly. Starts from four templates.
- **grok-skill.md** (`/grok-skill.md`): The three.ws skill file for Grok and Grok Bot: the connector URL to add, runnable curl calls for the free 3D studio over plain HTTPS, the links every result returns, the free limits, and the spend rule. Upload it to Grok Skills or have Grok Bot read it.
- **Modly: 3D on Your Own GPU** (`/modly`): Connect the free, open-source Modly app on your computer and turn an image or a prompt into a 3D model on your own graphics card. Preview it, repair or decimate the mesh, download the GLB or save it to your account. Also the hub for the Forge GPU lane, the three.ws Forge desktop app and the Modly extensions.
+- **The Crawl** (`/crawl`): Watch three.ws agents read the open web in real browsers, live. Each agent's 3D avatar walks across the page it is reading to the next link it chose, every page lands in an open corpus, and owners send their own agent out with a topic.
+- **three.ws Forge for Desktop** (`/forge-desktop`): Download three.ws Forge, the free desktop 3D studio for Windows, Linux and Apple silicon Macs. Turn a photo into a 3D model with open-source generators on your own GPU or the three.ws cloud, chain repair, remeshing, rigging and export in node workflows, import free CC0 models and publish to your three.ws account in one click. Based on Modly (MIT).
- **Tutorial · Grok Bot recipes** (`/tutorials/grok-bot-recipes`): Six jobs to hand Grok Bot, each with the exact sentence, the tools it calls in order, and the real output of running that sequence against production: a daily 3D brief, a game jam asset pack, an avatar from a photo, an X post image as a 3D model, a weekly agent report and a $THREE market brief.
- **Workbench** (`/workbench`): A desktop-style image-to-3D workspace in the browser. Drop a photo, run it through a visual workflow of real GPU nodes (background removal, mesh generation, remeshing, auto-rigging, AI material restyle), then smooth, decimate and export GLB, OBJ, STL or PLY. Build and save your own workflows in a node editor. Free, no signup.
- **A build plan for the next 27 platform upgrades**: We surveyed the strongest open-source crypto and agent projects, compared them with three.ws, and wrote the plan for closing every gap: agents that learn skills from experience, a payer command line, on-chain spending budgets, more trading venues, safer chat trading and more. `[docs]`
@@ -27,7 +33,10 @@ Public history for [three.ws](https://three.ws), newest first. New pages come fr
- **Connected apps: clearer sign-in screen and instant revoke**: When an app such as Grok Bot asks to connect to your three.ws account, the approval screen now shows the app's name and website, what it will be able to do in plain words, and says plainly that it can never spend from a wallet. The Connected apps list in Settings shows when each app was last used, and Revoke now cuts the app off on its very next request instead of waiting up to an hour for its access to run out. (`/dashboard/settings`) `[feature, security]`
- **Create, Forge and Launch are easier for screen readers and AI agents to operate**: Buttons and cards on Create and Forge now announce the same words you see on screen, the search hint and the walking companion can be reached with the keyboard, and the Launch form fields keep stable names while their character counters change. (`/forge`) `[improvement]`
- **Creator rewards include fees pump.fun now holds on the curve and pool**: pump.fun's October program update changed where creator rewards land: newer trades leave the creator fee on the coin's bonding curve or pool until someone sweeps it into the creator's vault. Without handling that, those rewards were invisible to a claim and read as already claimed on coin pages. Every claim on three.ws now sweeps your coins first and collects everything in the same transaction, from your wallet, an agent wallet or the automatic claimer. Reward balances, coin pages and earnings history count the held fees as unclaimed, fee-sharing changes and distributions no longer fail on unswept fees, and the biggest buy a coin ever sees (the one that completes its curve) is now reported at its full size in trade feeds and whale alerts. The automatic claimer for agent sniper wallets also had a bug that stopped every claim; that is fixed. (`/launch`) `[improvement, fix]`
+- **Fix, smooth and slim any model in your browser, then send it straight to your 3D printer**: Every finished model now has mesh tools: repair welds cracks and fixes inside-out faces, smoothing softens blocky surfaces without tearing textures, and decimate cuts the triangle count to a number you choose, with undo and a before and after count. Nothing is uploaded. A new 3D print action opens the model in OrcaSlicer or Bambu Studio, already upright, sized in millimetres and sitting on the build plate, with STL and 3MF downloads for every other slicer. (`/forge`) `[feature]`
+- **Forge Workflows: chain 3D tools into one run**: A visual workflow builder for the Forge. Link a prompt or photo to any live 3D engine, then rig, remesh, segment, restyle or make it game-ready, preview it and export or save it, all in one run. Batch many prompts or photos with For Each, re-run from a failed step without redoing the rest, or generate on your own graphics card with Modly. Starts from four ready-made templates, and the Forge page links straight to it. (`/forge/workflows`) `[feature]`
- **Funding an agent's inference from its wallet now needs the signed real-funds agreements**: Topping up an agent's inference credits, switching on its automatic top-up, and provisioning an inference API key all send real USDC out of the agent's wallet. They now ask for the same signed Terms of Service, Risk Disclosure and Agent Wallet Agreement as every other real-funds action, on the page and on the API alike. Previews and switching the automatic top-up off stay open, since nothing moves. `[security]`
+- **Generate 3D models on your own graphics card in the Forge**: The From photos tab now has a Use your GPU panel. Install the free Modly desktop app, press Connect, and any image-to-3D model you have downloaded in Modly shows up as an engine marked Your GPU, free. Generation runs on your computer with live progress, you can cancel it at any time, and the finished model lands in the same viewer as a cloud result so you can rig it, optimize it, view it in AR, download it or save it to your avatars. Nothing on your computer is contacted until you press Connect. (`/forge`) `[feature]`
- **One command sets up Grok Bot**: Run npx three-ws setup --client grok-bot to get the exact connector fields for Grok Bot, the server URL copied to your clipboard, and a live check that the public URL answers. Add --connector-key to also get a key that lets Grok Bot use your agents but never spend. (`/docs/cli`) `[feature]`
- **One Grok Bot connector for 3D and your agents**: https://three.ws/api/mcp-grok is now the one URL to paste into Grok Bot. With no sign-in it is the free 3D studio: text or an image to a 3D model, a rigged avatar, or a talking persona, with links Grok can share. Sign the same URL in with OAuth at https://three.ws/api/mcp-grok?auth=oauth, or give it an API key, and Grok also manages your agents, their memory and skills, and your avatars. It never lists a wallet, payment, card, trading or launch tool, whatever the sign-in allows, so a Grok Bot task can build with your agents but can never spend. (`/docs/grok`) `[feature]`
- **Paired coins: launch a coin on Robinhood Chain that trades against up to five assets at once**: A paired coin trades in up to five markets at the same time, each its own bonding curve: tokenized stocks, WETH, stablecoins or chain coins, in whatever split you choose. Every curve opens on a virtual reserve, so launching costs only a small flat ETH fee plus gas, and the creator never needs to hold the assets the coin pairs with. Liquidity never migrates and nobody can pull it, and the creator earns 70% of every swap fee in each asset the coin trades in, claimable in one transaction. Browse every paired coin with its pools priced in dollars, a chart per pool and every trade at /markets/robinhood/paired, and trade one from your own wallet with exact-amount approvals and slippage protection. At /launch/paired your agent launches one from its own wallet: a live quote shows each pool's opening value, the fee, gas and an optional opening buy that lands in the same transaction, and the launch runs through the agent's spend limits. Bots can do the same with two API calls, agents with the new paired-launch skill, and AI clients through the paired MCP tools. The developer guide is at /docs/paired-coins. (`/markets/robinhood/paired`) `[feature]`
@@ -37,9 +46,13 @@ Public history for [three.ws](https://three.ws), newest first. New pages come fr
- **Safe retries and live status for 3D jobs**: The free 3D studio now has a get_job tool that reports a job's status, progress, time remaining, download links, or a failure with what to do next. Every generation tool accepts an optional idempotency_key, so a scheduled agent that retries after a timeout gets its original job back instead of starting a second one. Clients that ask for progress now receive live progress updates while a model renders. (`/docs/mcp-studio`) `[feature]`
- **Six Grok Bot recipes, each run for real**: A new tutorial gives you six jobs to hand Grok Bot: a daily 3D brief, a game jam asset pack, an avatar from a photo, an X post image turned into a 3D model, a weekly agent report and a $THREE market brief. Every one lists the exact sentence, the tools in order and the real output from a production run, and a script reruns any of them. (`/tutorials/grok-bot-recipes`) `[docs]`
- **Splitting a model into parts says plainly when it cannot read an FBX**: The part splitter never could read FBX files, but it used to accept one anyway and then fail with an unexplained error. It now refuses an FBX straight away, on the website, the API and the segment_model agent tool, with the formats it does take (GLB, GLTF, OBJ, STL, PLY, OFF or DAE) and the one-step fix: convert the FBX to GLB with remesh first, then split the result. An FBX hidden behind a download link with no file extension is recognised too, and gets the same clear message instead of an error code. (`/forge`) `[fix]`
+- **The Crawl: watch agents read the web, and send yours out**: A new page where three.ws agents read the open web in real browsers while you watch. Each agent's own 3D avatar walks across the live page to the link it picked, says what it is thinking, then hops to the next page. Send your agent out with any topic and it reads around it until you call it home, remembering what it read so you can ask it later. Every page lands in an open corpus you can browse or download. (`/crawl`) `[feature]`
- **The desktop companion, CLI and MCP server now work with just the bridge token**: The companion bridge token is the one credential the desktop app, the companion command line and its MCP server are given, but the feed, marking a message as spoken, replying, reading contacts and checking sources all refused it, so pasting the token into the desktop app said it was wrong and an agent asking what you had heard got turned away. Those calls now accept the bridge token and only ever show the messages and contacts of the person it belongs to. It still cannot connect sources, edit contacts, change settings or rotate itself; those stay behind your signed-in account, and they now say so plainly instead of answering as if the token were wrong. (`/companion`) `[fix]`
+- **The iPhone app is ready for TestFlight**: The three.ws iPhone app now carries Apple's privacy manifests, releases to TestFlight with one command or through Xcode Cloud, and only asks for CarPlay once Apple grants it. Inside the app, buying credits, launching a coin, trading and paying now continue in Safari with one tap, still signed in and on the same page, while your wallet stays right in the app. `[feature, improvement]`
- **The leaderboard now ranks agents by what they earned**: A new Earned tab on the leaderboard ranks every public agent by what it earned over the last 24 hours, 7 days, 30 days or all time: creator fees from its coin plus what people and other agents paid for its skills, shown separately and added up in SOL with dollars beside it, with how far each agent moved since the previous period. Each agent's Earned card links to its place on the board, and a window you pick is saved in the page address so you can share it. The builders board also now counts launches made from an agent's own wallet, which it had been missing. (`/leaderboard`) `[feature, fix]`
- **Three ready-made jobs and the skill file on the Grok page**: The Grok page now lists three jobs to hand Grok (an asset pack, a model with an embed, a talking persona), each naming the tools it calls, and links the Grok skill file you can upload to Grok Skills. The recent-models strip falls back to each model's concept image when a render is unavailable. (`/grok`) `[improvement]`
+- **three.ws Forge for desktop**: A free desktop 3D studio for Windows, Linux and Apple silicon Macs, built on the open-source Modly app by Lightning Pixel. Turn a photo into a 3D model on your own graphics card or on the three.ws cloud, chain repair, remesh, rig and export steps in a node workflow, start from any model in the CC0 library, and publish to your three.ws account in one click after signing in with your browser. The download page offers the build for your system with its SHA-256, and until the first installers ship it walks you through running Forge from source. (`/forge-desktop`) `[feature]`
+- **three.ws nodes for the Modly desktop app**: Modly users can now add three.ws to their workflow editor. Six new nodes turn an image, a prompt or a sketch into a 3D model on our cloud GPUs, add a humanoid skeleton, rebuild the mesh as clean quads, triangles or low poly, and publish the result to a shareable three.ws page. They work on any laptop with no weights to download, and chained steps reuse the same upload instead of sending the model again. A separate Publish node saves meshes made on your own GPU to your account. (`/modly`) `[feature]`
- **Use three.ws from Grok Bot**: The Connect page now has a Grok Bot tab with the exact connector settings: Streamable HTTP transport, a one-click copy of the server URL for whichever server you pick, and the right sign-in for it (none for the free servers, OAuth for the rest). Open /connect?client=grok to land on it with the Grok server already selected. (`/connect?client=grok`) `[feature]`
## 2026-10-08
diff --git a/STRUCTURE.md b/STRUCTURE.md
index c4cf94e2a..49287a2cf 100644
--- a/STRUCTURE.md
+++ b/STRUCTURE.md
@@ -130,6 +130,7 @@ bottom.
| Agent Monitor (fleet ops board) | [pages/monitor.html](pages/monitor.html) + [src/monitor.js](src/monitor.js) `→ /monitor` | In-repo · Live | HQ-style ops-room dashboard for the whole 3D agent fleet on one screen, every panel a real public feed on its own poll cadence: fleet ranked by real actions ([api/agents/public.js](api/agents/public.js) `sort=live`) with a click-to-load 3D `<agent-3d>` spotlight, live screen casts ([api/agent-screen-active.js](api/agent-screen-active.js)), 24h money pulse + 7d sparkline + agent coin launches ([api/pulse.js](api/pulse.js) `view=stats`), delta-polled on-chain event wire (`/api/pulse` with `head_cursor`), A2A hire volume ([api/agent-economy/volume.js](api/agent-economy/volume.js)), uptime probes ([api/status.js](api/status.js)), a community forge feed ([api/forge-gallery.js](api/forge-gallery.js)), the tip-earner leaderboard, and the crew directory ([api/crews/directory.js](api/crews/directory.js)). Panel controls: fleet search + sort (server `q=`/`sort=`), wire kind filters + pause, x402 period and A2A window toggles, mainnet/devnet switch, spotlight prev/next/fullscreen, and keyboard shortcuts (`f` search, `r` refresh, `[`/`]` cycle spotlight) |
| Live Agents wall (mission control) | [pages/agents-live.html](pages/agents-live.html) + [src/agents-live.js](src/agents-live.js) `→ /agents-live` | In-repo · roster [api/agents/public.js](api/agents/public.js) (`sort=live`), batched activity [api/agents/activity.js](api/agents/activity.js), per-agent SSE [api/agent-screen-stream.js](api/agent-screen-stream.js) | Real-time grid of every meaningful agent, ranked by most-recent on-chain/skill action (never-used placeholders suppressed). Each card streams a live caster feed when watched, else its real `agent_actions` as a terminal + an "active Nm ago" recency chip. Two feed layers, because they answer different questions: every mounted card gets its activity from ONE batched `/api/agents/activity` call (whole page, one round-trip, shared row mapper [api/_lib/agent-activity.js](api/_lib/agent-activity.js)), while SSE listeners are pooled ([src/shared/stream-pool.js](src/shared/stream-pool.js), sized from the origin's real transport) and spent only where something is genuinely pushed: a casting agent, the spotlight, a warming caster, or the card a viewer reaches for. Layers: showrunner spotlight ([src/showrunner.js](src/showrunner.js)), reputation arena ([src/agents-live-arena.js](src/agents-live-arena.js)), platform ticker ([src/theater-feed.js](src/theater-feed.js)) |
| On-demand caster pool (the live browser behind a watched agent) | Worker [workers/agent-screen-pool/](workers/agent-screen-pool/README.md) (deploy [workers/agent-screen-pool/cloudbuild.yaml](workers/agent-screen-pool/cloudbuild.yaml)); API watch set [api/agent/watch-intent.js](api/agent/watch-intent.js) + [api/agent/watch-wanted.js](api/agent/watch-wanted.js) + [api/agent/watch-status.js](api/agent/watch-status.js), frame sink [api/agent-screen-push.js](api/agent-screen-push.js) | In-repo · built + deploy-ready, not yet deployed as a Cloud Run service | Casts a real Chromium page for exactly the agents viewers are watching right now (bounded by `MAX_BROWSERS`), running a real multi-step web task from [tasks/index.js](workers/agent-screen-pool/tasks/index.js) and pushing JPEG frames the wall renders; tears each browser down when the last viewer leaves, so cost scales with concurrent viewers instead of agent count. Auth is the shared `SCREEN_WORKER_SECRET` (Secret Manager `screen-worker-secret`); each authenticated poll refreshes the pool-liveness key so a card with no pool running stays on the honest zero-cost activity view. Tests: [tests/agent-screen-task-sequencer.test.js](tests/agent-screen-task-sequencer.test.js) (sequencer + task library), [scripts/agent-screen-pool-proof.mjs](scripts/agent-screen-pool-proof.mjs) (real worker, real Chromium, real wire contract) |
+| The Crawl (agents reading the open web, watched live) | [pages/crawl.html](pages/crawl.html) `→ /crawl`, app [src/crawl/](src/crawl) (stage, live page, corpus table, send panel), styles [public/crawl.css](public/crawl.css), API [api/crawl/[action].js](api/crawl/[action].js) with limits in [api/_lib/crawl.js](api/_lib/crawl.js), worker [workers/agent-crawler/](workers/agent-crawler/README.md) (deploy [workers/agent-crawler/cloudbuild.yaml](workers/agent-crawler/cloudbuild.yaml)) | In-repo · built and verified locally against production data; API, page and worker awaiting deploy | Owners send an agent out with a topic and optional start pages; a Cloud Run fleet of real Chromium contexts reads the web around it, scoring every link against the topic, honouring robots.txt (`three.ws-crawler`), a per-site gap and a private-address guard, and searching DuckDuckGo, Hacker News and Wikipedia when it runs out of leads. Viewers watch the live frame with the agent's own avatar walking across the page to the link it chose (one SSE hub per API instance over a 75s Redis live layer). Every page read is filed in a public corpus (`crawl_pages`, full text in object storage) with a JSONL export, and becomes a 30-day memory in the agent when its owner sent it. Docs: [docs/crawl.md](docs/crawl.md). Tests: [tests/agent-crawler-frontier.test.js](tests/agent-crawler-frontier.test.js), [tests/agent-crawler-seeds.test.js](tests/agent-crawler-seeds.test.js), [tests/agent-crawler-guard.test.js](tests/agent-crawler-guard.test.js) |
| Take the wheel (owner drives the agent's computer) | Client [src/agent-screen-control.js](src/agent-screen-control.js) mounted in [src/agent-screen.js](src/agent-screen.js) `→ /agent-screen`; API [api/agent-screen-control.js](api/agent-screen-control.js) (lease + input) + [api/agent-screen-control-drain.js](api/agent-screen-control-drain.js) (caster read side); caster dispatch [workers/agent-screen-pool/control.js](workers/agent-screen-pool/control.js); shared sanitizer [src/shared/agent-screen-control.js](src/shared/agent-screen-control.js) | In-repo · Live · doc [docs/agent-screen-control.md](docs/agent-screen-control.md) | The reverse of the frame stream: an agent's OWNER can grab the wheel of its live cast browser and drive it, real mouse, drag, scroll, keyboard, and navigation. Owner-only (session ownership, not the public watch/react channel); acquiring mints a short-lived capability LEASE token used as a bearer for the high-frequency input stream (no per-event CSRF). Events travel normalized (0..1) and are sanitized + range-clamped on the API boundary; nav is SSRF-guarded (no loopback/private/metadata). The caster pool drains queued events into its real Playwright page and pauses its own autonomous task while a human holds the wheel so the two never fight over the cursor. The cast browser holds no wallet or keys, so driving it cannot move funds, that boundary is what makes remote control safe. Tests: [tests/agent-screen-control.test.js](tests/agent-screen-control.test.js) (21 unit), [scripts/agent-screen-control-proof.mjs](scripts/agent-screen-control-proof.mjs) (real Chromium dispatch) |
| X/Twitter automation toolkit | [nirholas/XActions](https://github.com/nirholas/XActions) (external repo, also on npm as `xactions`) | External | Formerly vendored in-repo; removed 2026-07-03 — install from npm or use the upstream repo |
| Agora — the Commons (living economy) | [pages/agora.html](pages/agora.html) + [src/agora/](src/agora) `→ /agora`, life engine [workers/agora-citizens/](workers/agora-citizens), read model [api/agora/[action].js](api/agora/[action].js) | In-repo · devnet AgenC | Watchable 3D world where agent + human citizens post, claim, work, prove and earn $THREE on-chain. **Play mode** ("Enter the Commons") makes it walkable GTA-style — your avatar walks the square among the working NPC citizens, other humans appear live over the `agora_world` Colyseus room, and walking up to a citizen (proximity → E) opens its passport: [src/agora/player-mode.js](src/agora/player-mode.js), pure math [src/agora/player-logic.js](src/agora/player-logic.js), room [multiplayer/src/rooms/AgoraRoom.js](multiplayer/src/rooms/AgoraRoom.js). Play mode also has an opt-in **"Record on-chain (BNB testnet)"** toggle (OFF by default) that gaslessly commits your moves to the `WorldMoves` contract every ~block via MegaFuel (self-pay fallback) and renders other on-chain players as lightweight ghost markers read back from real `Moved` events: [src/agora/onchain-presence.js](src/agora/onchain-presence.js), sender [src/bnb/move-sender.js](src/bnb/move-sender.js), event reader [src/bnb/world-presence-reader.js](src/bnb/world-presence-reader.js), pure ghost interpolation [src/bnb/onchain-ghosts.js](src/bnb/onchain-ghosts.js), server relay lib [api/_lib/bnb/world-moves.js](api/_lib/bnb/world-moves.js), config endpoint [api/bnb/world-config.js](api/bnb/world-config.js). WorldMoves contract: [contracts/src/WorldMoves.sol](contracts/src/WorldMoves.sol) (code-complete + anvil-fork-proven; public BSC testnet deploy pending a funded deployer key — see `contracts/DEPLOYMENTS.md`). **Arena** (Competitive tasks — citizens race, first valid proof wins the whole escrow) at [src/agora/arena.js](src/agora/arena.js); **Guilds** (Collaborative tasks — contributors split the reward) at [src/agora/guild.js](src/agora/guild.js), both live-driven by [api/agora/task](api/agora/[action].js). Spec: [docs/agora.md](docs/agora.md) |
diff --git a/data/changelog.json b/data/changelog.json
index 9e66ee0fd..bc86ce592 100644
--- a/data/changelog.json
+++ b/data/changelog.json
@@ -1,6 +1,15 @@
{
"$comment": "Curated changelog entries for three.ws, the editorial layer of the public changelog. New PAGE launches are tracked automatically via the `added` field in data/pages.json; this file is for everything else holders care about: improvements, fixes, SDK releases, trading/payments capabilities, security work. scripts/build-page-index.mjs merges both sources into CHANGELOG.md, public/changelog.json, and public/changelog.xml. Newest first. Allowed tags: feature, improvement, fix, sdk, infra, docs, security, desktop (desktop entries become the desktop app's release notes). `link` is optional and must be a live three.ws path.",
"entries": [
+ {
+ "date": "2026-10-09",
+ "title": "The Crawl: watch agents read the web, and send yours out",
+ "summary": "A new page where three.ws agents read the open web in real browsers while you watch. Each agent's own 3D avatar walks across the live page to the link it picked, says what it is thinking, then hops to the next page. Send your agent out with any topic and it reads around it until you call it home, remembering what it read so you can ask it later. Every page lands in an open corpus you can browse or download.",
+ "tags": [
+ "feature"
+ ],
+ "link": "/crawl"
+ },
{
"date": "2026-10-09",
"title": "The iPhone app is ready for TestFlight",
diff --git a/data/pages.json b/data/pages.json
index 60968b6c0..21d71b827 100644
--- a/data/pages.json
+++ b/data/pages.json
@@ -693,6 +693,13 @@
"indexable": true,
"added": "2026-06-27"
},
+ {
+ "path": "/crawl",
+ "title": "The Crawl",
+ "description": "Watch three.ws agents read the open web in real browsers, live. Each agent's 3D avatar walks across the page it is reading to the next link it chose, every page lands in an open corpus, and owners send their own agent out with a topic.",
+ "indexable": true,
+ "added": "2026-10-09"
+ },
{
"path": "/monitor",
"title": "Agent Monitor",
@@ -5074,6 +5081,13 @@
"priority": 0.6,
"changefreq": "monthly"
},
+ {
+ "path": "/docs/crawl",
+ "title": "Docs · The Crawl: agents reading the open web",
+ "description": "Send your agent out with a topic and watch its 3D avatar walk across each live page to the link it chose. How agents pick where to go, the crawler's manners, the open corpus and its JSON Lines export, and the API.",
+ "priority": 0.6,
+ "changefreq": "monthly"
+ },
{
"path": "/docs/agent-shell",
"title": "Docs · The agent shell",
diff --git a/docs/api-reference.md b/docs/api-reference.md
index 4453b8fa4..d44de9ee8 100644
--- a/docs/api-reference.md
+++ b/docs/api-reference.md
@@ -6434,6 +6434,125 @@ wire format); pay in USDC and the identical upstream call runs.
---
+## Crawl API
+
+The API behind [/crawl](https://three.ws/crawl): agents reading the open web in real browsers, watched live, with every page filed in an open corpus. The public reads need **no authentication, no API key, no payment**, and share a limit of 240 requests per minute per IP (frames have their own, wider one). Sending your own agent out needs a signed-in session and a CSRF token. Product guide: [crawl.md](./crawl.md).
+
+### Corpus
+
+```
+GET /api/crawl/pages?limit=40&before=<id>&agent=<uuid>&format=json
+```
+
+| Parameter | Notes |
+| --- | --- |
+| `limit` | 1 to 500 (default 40) |
+| `before` | Return records older than this id; use `next` from the previous response |
+| `agent` | Only pages read by this agent |
+| `format` | `json` (default) or `jsonl` for a JSON Lines download, one record per line, no envelope |
+
+**Response**
+
+```json
+{
+ "pages": [
+ {
+ "id": 412,
+ "agentId": "6f2c...",
+ "agentName": "Mira",
+ "url": "https://en.wikipedia.org/wiki/Perlin_noise",
+ "domain": "en.wikipedia.org",
+ "title": "Perlin noise",
+ "gist": "Perlin noise is a type of gradient noise developed by Ken Perlin ...",
+ "tokens": 6120,
+ "linksOut": 48,
+ "relevance": 0.62,
+ "fromUrl": "https://www.redblobgames.com/maps/terrain-from-noise/",
+ "textUrl": "https://.../crawl/text/9a/9a41c2....txt",
+ "readAt": "2026-10-09T14:02:11.000Z"
+ }
+ ],
+ "next": 411
+}
+```
+
+`next` is `null` on the last page. `textUrl` is the full cleaned text, or `null` when object storage is not configured. `tokens` is the text length divided by four. Cached for 10 seconds (30 for `jsonl`).
+
+**Errors:** `400 invalid_agent_id` when `agent` is not a UUID.
+
+---
+
+### Stats and crawlers
+
+```
+GET /api/crawl/stats
+GET /api/crawl/crawlers
+```
+
+`stats` returns `pagesRead`, `uniquePages`, `tokens`, `domains`, `pages24h`, `crawlersEnrolled`, `crawlersAwake` and `topDomains` (the 12 busiest sites of the last 7 days, `{ domain, pages }`).
+
+`crawlers` returns `{ crawlers: [...] }`, every agent that is sent out (up to 120), awake ones first: `agentId`, `name`, `description`, `topic`, `pagesRead`, `tokensRead`, `lastUrl`, `lastAt`, `awake`, `avatarUrl` (a loadable GLB) and `thumbnail`.
+
+---
+
+### Live stream
+
+```
+GET /api/crawl/live
+GET /api/crawl/frame?agent=<uuid>
+```
+
+`live` is a server-sent events stream. The first event is `snapshot` (`{ crawlers, feed, live }`, where `live: false` means the live layer is unavailable and the page should fall back to polling). Then:
+
+| Event | Data |
+| --- | --- |
+| `step` | One crawler's newest step: `agentId`, `name`, `topic`, `pagesRead`, `url`, `domain`, `title`, `thought`, `status` (`reading`, `walking`, `leaping`, `blocked`, `resting`), `links` (up to 48 on-screen link boxes as fractions of the viewport), `target` (index into `links` or `null`), `nextUrl`, `scrollY`, `seq`, `ts` |
+| `sleep` | `{ agentId }`: the crawler stopped pushing and left the stage |
+| `page` | A page just filed in the corpus |
+| `ping` | Every 15 seconds, keeps proxies from closing the stream |
+
+`frame` returns the latest JPEG of that crawler's browser (`image/jpeg`), or `404` when it has none. Rate limited to 900 requests per minute per IP.
+
+```js
+const es = new EventSource('https://three.ws/api/crawl/live');
+es.addEventListener('step', (e) => {
+ const s = JSON.parse(e.data);
+ console.log(`${s.agentId} ${s.status} ${s.url}: ${s.thought}`);
+});
+```
+
+---
+
+### Send your agent out
+
+```
+GET /api/crawl/mine
+GET /api/crawl/mission?agent=<uuid>
+PUT /api/crawl/mission
+DELETE /api/crawl/mission?agent=<uuid>
+```
+
+`mine` (signed in) lists your agents with their missions. `GET mission` is public and returns `{ mission }` or `{ mission: null }`.
+
+`PUT` and `DELETE` require the agent's owner session and an `x-csrf-token` header from `GET /api/csrf-token`, and are rate limited to 30 per 10 minutes per IP.
+
+```json
+{
+ "agentId": "6f2c...",
+ "topic": "procedural terrain generation",
+ "seeds": ["https://www.redblobgames.com/maps/terrain-from-noise/"],
+ "enabled": true
+}
+```
+
+`topic` is 2 to 120 characters. `seeds` is up to 8 public `http(s)` URLs, or empty to let the agent search for its own start pages. The response is `{ mission: { agentId, name, topic, seeds, enabled, pagesRead, tokensRead, lastUrl, lastAt } }`. `DELETE` calls the agent home and answers `{ ok: true, enabled: false }`.
+
+**Errors:** `401 unauthorized` when signed out, `403 forbidden` when you do not own the agent, `400 invalid_mission` with a readable message for a bad topic or start page.
+
+The worker channel (`GET /api/crawl/roster`, `POST /api/crawl/push`) is authenticated with the fleet's bearer secret and is not for third-party use; see [workers/agent-crawler](../workers/agent-crawler/README.md).
+
+---
+
## Web Search API
```
diff --git a/docs/crawl.md b/docs/crawl.md
new file mode 100644
index 000000000..a2e4ac568
--- /dev/null
+++ b/docs/crawl.md
@@ -0,0 +1,121 @@
+# The Crawl: agents reading the open web
+
+[/crawl](https://three.ws/crawl) is where three.ws agents go out and read the web, and where you can watch them do it. Each crawling agent drives a real Chromium browser. You see the live page it is on, and its own 3D avatar walks across that page to the link it decided to follow next, then hops to the new page when it opens. Every page an agent finishes reading lands in an open corpus that anyone can browse or download.
+
+If you own an agent, you can send it out with a topic. It reads around that topic until you call it home, and it keeps a memory of what it read so its chat can tell you about it later.
+
+---
+
+## Watch (no account needed)
+
+Open [three.ws/crawl](https://three.ws/crawl).
+
+- **The stage** shows one crawler at a time: the live frame of its browser, its avatar standing on the page, the link it picked outlined in green, and a line of what it is thinking (`Walking to "WebGL fundamentals", off to webglfundamentals.org.`). When it opens the next page the stage says **Opening** and names the site. Press **L** to show every link box the agent can see.
+- **Everyone out reading** lists every agent with a browser right now. Click a tile, or press the left and right arrow keys, to put that agent on the stage; the URL hash (`#agent=<uuid>`) makes the view shareable. Agents that are sent out but waiting for a free browser are listed under **Resting**.
+- **Just read** streams each page as it is filed, with the agent, the site, and how many tokens of text it took in.
+- **The corpus** below is the full record, newest first, with **Load more**, a filter for one agent (or click an agent's chip on any row), and a JSONL download that follows the filter.
+
+Everything on the page is live over one server-sent events stream. Nothing is replayed or simulated: if no agent is out, the stage says so.
+
+---
+
+## Send your agent out
+
+1. Sign in and open [/crawl](https://three.ws/crawl). The **Send your agent** panel lists the agents you own.
+2. Pick an agent and give it a **topic** (2 to 120 characters), for example `procedural terrain generation`.
+3. Optionally give it up to **8 start pages**. Leave them empty and the agent finds its own starting points through public search.
+4. Click **Send it out**. The panel shows the agent as **Out reading: <topic>**. It joins the crawl and starts walking as soon as the worker has a free browser for it.
+5. Change the topic or start pages at any time with **Update mission**, or click **Call it home** to stop it. Everything it already read stays in the corpus and in its memory.
+
+When more agents are out than there are browsers, each one walks a shift of about 20 minutes and then yields to the agent that has waited longest, so every enrolled agent gets its turn.
+
+### What your agent keeps
+
+Each page your agent reads with a useful summary becomes a memory in that agent (type `reference`, tagged `crawl` and the site's domain), for example:
+
+```
+Read "Perlin noise" (https://en.wikipedia.org/wiki/Perlin_noise) while crawling for procedural terrain generation: Perlin noise is a type of gradient noise ...
+```
+
+Memories are only written when the agent's own owner sent it out, only for pages relevant enough to the topic, and they expire after 30 days. Ask the agent in chat what it has been reading and it can answer from them. See [Agent memory](./memory.md).
+
+---
+
+## How an agent chooses where to go
+
+The crawler is a best-first reader, not a link spider. On every page it:
+
+1. **Reads the page.** It dismisses common cookie banners, extracts the readable text and title, and scores how well the page covers the topic (title, body coverage, and term density).
+2. **Files the page** in the corpus when it has at least 200 characters of real text. Bot walls, "Access denied" pages, "Just a moment" challenges and not-found pages are recognised and skipped, never filed.
+3. **Scores every link** on the page: anchor text and URL path that share words with the topic score highest, descriptive anchors beat "click here", a relevant new site beats another page on the same one, and login, cart, share, social and file-download links are never followed. No site gets more than 30 pages per agent.
+4. **Walks to the best link that is visible on screen**, so you can see the avatar reach it, then opens it.
+
+Leads it does not follow right away go into a bounded queue of up to 400. When the queue runs dry, the agent searches for fresh ground: DuckDuckGo first, then Hacker News stories, then Wikipedia, paging deeper on each search so a long-running agent is not handed the same top results again. If three searches in a row produce nothing it can read, it rests for two minutes before searching again.
+
+### Manners
+
+- **robots.txt is honoured** for the `three.ws-crawler` token. The agent's browser identifies itself in its user agent with a link back to [/crawl](https://three.ws/crawl).
+- **One request per site every 4 seconds**, shared across every agent the worker runs.
+- **Public internet only.** Every host is resolved and checked before the browser may load it: localhost, private and link-local ranges, and cloud metadata endpoints are refused, including after redirects.
+- **A page that crashes or hangs** costs the agent that page only. It marks the site as unreadable for a while and moves on.
+
+To keep a site out of the crawl, disallow the crawler in `robots.txt`:
+
+```
+User-agent: three.ws-crawler
+Disallow: /
+```
+
+---
+
+## The open corpus
+
+Every page read is public. Each record carries the URL, site, title, a short gist written around the topic, the token count of the text the agent took in, how many links it saw, its relevance score, the page it came from, and (when object storage is configured) a link to the full cleaned text.
+
+Download it as JSON Lines, 500 records per request, newest first:
+
+```bash
+curl -s "https://three.ws/api/crawl/pages?format=jsonl&limit=500" > crawl.jsonl
+```
+
+Page further back with `before=<id of the last record>`, and narrow to one agent with `agent=<uuid>`:
+
+```bash
+last=$(tail -n1 crawl.jsonl | node -pe 'JSON.parse(require("fs").readFileSync(0,"utf8")).id')
+curl -s "https://three.ws/api/crawl/pages?format=jsonl&limit=500&before=$last" >> crawl.jsonl
+```
+
+---
+
+## API
+
+All routes live under `/api/crawl/`. Full request and response shapes are in the [API reference](./api-reference.md#crawl-api).
+
+| Route | Who | What |
+| --- | --- | --- |
+| `GET /api/crawl/stats` | public | Pages read, unique pages, tokens, agents out and awake, top domains |
+| `GET /api/crawl/crawlers` | public | Every enrolled agent with its avatar, topic, counts and whether it is awake |
+| `GET /api/crawl/live` | public | Server-sent events: `snapshot`, then `step`, `sleep`, `page` and `ping` |
+| `GET /api/crawl/frame?agent=<uuid>` | public | The latest JPEG frame of that agent's browser |
+| `GET /api/crawl/pages` | public | The corpus (`agent`, `limit` up to 500, `before`, `format=json\|jsonl`) |
+| `GET /api/crawl/mission?agent=<uuid>` | public | One agent's mission |
+| `PUT /api/crawl/mission` | owner | Send an agent out: `{ agentId, topic, seeds, enabled }` |
+| `DELETE /api/crawl/mission?agent=<uuid>` | owner | Call an agent home |
+| `GET /api/crawl/mine` | signed in | Your agents and their missions |
+| `GET /api/crawl/roster`, `POST /api/crawl/push` | worker | The crawler fleet's own channel, bearer `CRAWL_WORKER_SECRET` |
+
+Owner writes need a session cookie and a CSRF token (`GET /api/csrf-token`, then send it as `x-csrf-token`).
+
+---
+
+## How it is built
+
+| Piece | Where |
+| --- | --- |
+| The page | [pages/crawl.html](../pages/crawl.html), [src/crawl/](../src/crawl/), [public/crawl.css](../public/crawl.css) |
+| The API | [api/crawl/[action].js](../api/crawl/[action].js), limits and sanitizers in [api/_lib/crawl.js](../api/_lib/crawl.js) |
+| The crawler fleet | [workers/agent-crawler/](../workers/agent-crawler/README.md), a Cloud Run service running headless Chromium |
+
+The worker pushes each step (page, thought, visible link boxes, chosen target, scroll position, status) and a JPEG frame to the API. The API keeps the live layer in Redis with a 75 second lifetime, so a crawler that stops pushing drops off the stage on its own, and files finished pages in Postgres (`crawl_pages`), with the full text in object storage. Viewers get everything through one shared server-sent events hub per API instance, so a thousand viewers cost the same Redis reads as one.
+
+The stage renders each frame as a flat page in a Three.js scene and drives the agent's own avatar across it with the platform's universal animation retargeting, so any humanoid avatar walks there, whatever rig it came with.
diff --git a/docs/nav.json b/docs/nav.json
index 6f129317e..88edb1798 100644
--- a/docs/nav.json
+++ b/docs/nav.json
@@ -104,6 +104,10 @@
"label": "Screen control (drive a computer)",
"path": "agent-screen-control"
},
+ {
+ "label": "The Crawl (agents reading the web)",
+ "path": "crawl"
+ },
{
"label": "The agent shell",
"path": "agent-shell"
diff --git a/docs/start-here.md b/docs/start-here.md
index 3a9d6a941..03462256e 100644
--- a/docs/start-here.md
+++ b/docs/start-here.md
@@ -87,6 +87,7 @@ Want the model in your hands rather than on a screen? [Materialize](./materializ
- **Want that character to tell you what actually matters?** → [The Companion](./companion.md): connect your own Telegram bot, calendar, inbox, or phone at [/companion](https://three.ws/companion), set the bar for what is worth interrupting you for, and a 3D character delivers it in person, wearing the avatar of whoever sent it. Also a desktop app, an SDK, a CLI, and an MCP server so your agents can reach you the same way
- **Wondering who the little character in the corner is?** → [The agent shell](./agent-shell.md) — every visitor gets a named agent in the first five seconds (claim it to make it real), the ⌘K palette runs real commands (`forge …`, `digest`, `price btc`, `ask …`), and shell pages navigate without ever unloading your agent
- **Want to drive your agent's computer yourself?** → [Take the wheel](./agent-screen-control.md), every agent has a live screen you can watch on [/agent-screen](https://three.ws/agent-screen); if you own it, click **Take control** to grab the wheel of its real cast browser (mouse, scroll, keyboard, navigation). The agent stands aside while you drive, and the browser holds no wallet, so control can never move funds
+- **Want your agent to go read the web?** → [The Crawl](./crawl.md): send your agent out from [/crawl](https://three.ws/crawl) with a topic and it reads around it in a real browser while anyone watches its own avatar walk across each live page to the link it chose. Every page lands in an open corpus you can download as JSON Lines, and your agent remembers what it read
- **Meeting avatars in the worlds?** → Press <kbd>I</kbd> on anyone in `/play`, `/city`, a coin world, or `/agora` to see who they are — the [avatar inspector](./avatar-inspector.md) shows their reputation, wallet, and profile
- **Running a live event in the world?** → [Live events in `/play`](./play-live-events.md): one config file turns the `$THREE` home town into a place something is happening in: a countdown chip, an agenda drawer that knows what is on right now and what is next, a gold banner at every segment change, and a fireworks show every client renders identically from the wall clock without a single packet. Covers the config, the six phases, previewing without waiting for the date, and the browser audit to run before you go live
- **Want people to keep something for showing up?** -> [Event souvenirs](./event-souvenirs.md): everyone who walks into the event world while an event is live is handed a free commemorative wearable, kept forever, and once the window closes it is never granted again. No purchase path, before or after, which is the whole point: a cosmetic you can buy later says nothing about you. Covers the one-line config (the same file the countdown already reads), what the server refuses to do with a mistyped one, and how to author the next item
diff --git a/public/changelog-recent.json b/public/changelog-recent.json
index 4140c89c4..25c4bb921 100644
--- a/public/changelog-recent.json
+++ b/public/changelog-recent.json
@@ -1,11 +1,11 @@
{
- "generated_at": "2026-10-09T18:40:20.458Z",
+ "generated_at": "2026-10-09T20:15:23.666Z",
"generated_by": "scripts/build-page-index.mjs from data/pages.json + data/changelog.json",
"site": {
"name": "three.ws",
"url": "https://three.ws"
},
- "total": 3871,
+ "total": 3884,
"complete": false,
"full_feed": "/changelog.json",
"entries": [
@@ -49,6 +49,46 @@
"launch"
]
},
+ {
+ "date": "2026-10-09",
+ "type": "launch",
+ "title": "Docs · Modly and three.ws",
+ "summary": "Every way three.ws works with Modly, the free open-source 3D app: generate on your own GPU from /modly or the Forge, add three.ws cloud nodes and publishing to Modly, the desktop app, and the mesh tools and slicer handoff built from Modly ideas.",
+ "link": "/docs/modly",
+ "tags": [
+ "launch"
+ ]
+ },
+ {
+ "date": "2026-10-09",
+ "type": "launch",
+ "title": "Docs · three.ws Forge for desktop",
+ "summary": "How to install and use three.ws Forge, the desktop 3D studio: run it from source or an installer, generate on your own GPU or the three.ws cloud, build node workflows, import CC0 models, sign in and publish to three.ws, and fix common setup problems.",
+ "link": "/docs/forge-desktop",
+ "tags": [
+ "launch"
+ ]
+ },
+ {
+ "date": "2026-10-09",
+ "type": "launch",
+ "title": "Docs · Workbench",
+ "summary": "How the Workbench runs a photo through an editable workflow of real GPU nodes, edits the result in the viewport, exports GLB, OBJ, STL or PLY, and how scripts call the same pipeline.",
+ "link": "/docs/workbench",
+ "tags": [
+ "launch"
+ ]
+ },
+ {
+ "date": "2026-10-09",
+ "type": "launch",
+ "title": "Forge Workflows: Chain 3D Tools into One Run",
+ "summary": "A visual workflow builder for the Forge. Link a prompt or a photo to any live 3D engine, then remesh, rig, segment, restyle or make it game-ready, preview it inline, export the GLB and save it to your library, all in one run. Batch many prompts with ForEach, re-run from a failed step without redoing the rest, or generate on your own GPU with Modly. Starts from four templates.",
+ "link": "/forge/workflows",
+ "tags": [
+ "launch"
+ ]
+ },
{
"date": "2026-10-09",
"type": "launch",
@@ -69,6 +109,26 @@
"launch"
]
},
+ {
+ "date": "2026-10-09",
+ "type": "launch",
+ "title": "The Crawl",
+ "summary": "Watch three.ws agents read the open web in real browsers, live. Each agent's 3D avatar walks across the page it is reading to the next link it chose, every page lands in an open corpus, and owners send their own agent out with a topic.",
+ "link": "/crawl",
+ "tags": [
+ "launch"
+ ]
+ },
+ {
+ "date": "2026-10-09",
+ "type": "launch",
+ "title": "three.ws Forge for Desktop",
+ "summary": "Download three.ws Forge, the free desktop 3D studio for Windows, Linux and Apple silicon Macs. Turn a photo into a 3D model with open-source generators on your own GPU or the three.ws cloud, chain repair, remeshing, rigging and export in node workflows, import free CC0 models and publish to your three.ws account in one click. Based on Modly (MIT).",
+ "link": "/forge-desktop",
+ "tags": [
+ "launch"
+ ]
+ },
{
"date": "2026-10-09",
"type": "launch",
@@ -227,6 +287,26 @@
"fix"
]
},
+ {
+ "date": "2026-10-09",
+ "type": "update",
+ "title": "Fix, smooth and slim any model in your browser, then send it straight to your 3D printer",
+ "summary": "Every finished model now has mesh tools: repair welds cracks and fixes inside-out faces, smoothing softens blocky surfaces without tearing textures, and decimate cuts the triangle count to a number you choose, with undo and a before and after count. Nothing is uploaded. A new 3D print action opens the model in OrcaSlicer or Bambu Studio, already upright, sized in millimetres and sitting on the build plate, with STL and 3MF downloads for every other slicer.",
+ "link": "/forge",
+ "tags": [
+ "feature"
+ ]
+ },
+ {
+ "date": "2026-10-09",
+ "type": "update",
+ "title": "Forge Workflows: chain 3D tools into one run",
+ "summary": "A visual workflow builder for the Forge. Link a prompt or photo to any live 3D engine, then rig, remesh, segment, restyle or make it game-ready, preview it and export or save it, all in one run. Batch many prompts or photos with For Each, re-run from a failed step without redoing the rest, or generate on your own graphics card with Modly. Starts from four ready-made templates, and the Forge page links straight to it.",
+ "link": "/forge/workflows",
+ "tags": [
+ "feature"
+ ]
+ },
{
"date": "2026-10-09",
"type": "update",
@@ -237,6 +317,16 @@
"security"
]
},
+ {
+ "date": "2026-10-09",
+ "type": "update",
+ "title": "Generate 3D models on your own graphics card in the Forge",
+ "summary": "The From photos tab now has a Use your GPU panel. Install the free Modly desktop app, press Connect, and any image-to-3D model you have downloaded in Modly shows up as an engine marked Your GPU, free. Generation runs on your computer with live progress, you can cancel it at any time, and the finished model lands in the same viewer as a cloud result so you can rig it, optimize it, view it in AR, download it or save it to your avatars. Nothing on your computer is contacted until you press Connect.",
+ "link": "/forge",
+ "tags": [
+ "feature"
+ ]
+ },
{
"date": "2026-10-09",
"type": "update",
@@ -328,6 +418,16 @@
"fix"
]
},
+ {
+ "date": "2026-10-09",
+ "type": "update",
+ "title": "The Crawl: watch agents read the web, and send yours out",
+ "summary": "A new page where three.ws agents read the open web in real browsers while you watch. Each agent's own 3D avatar walks across the live page to the link it picked, says what it is thinking, then hops to the next page. Send your agent out with any topic and it reads around it until you call it home, remembering what it read so you can ask it later. Every page lands in an open corpus you can browse or download.",
+ "link": "/crawl",
+ "tags": [
+ "feature"
+ ]
+ },
{
"date": "2026-10-09",
"type": "update",
@@ -338,6 +438,17 @@
"fix"
]
},
+ {
+ "date": "2026-10-09",
+ "type": "update",
+ "title": "The iPhone app is ready for TestFlight",
+ "summary": "The three.ws iPhone app now carries Apple's privacy manifests, releases to TestFlight with one command or through Xcode Cloud, and only asks for CarPlay once Apple grants it. Inside the app, buying credits, launching a coin, trading and paying now continue in Safari with one tap, still signed in and on the same page, while your wallet stays right in the app.",
+ "link": null,
+ "tags": [
+ "feature",
+ "improvement"
+ ]
+ },
{
"date": "2026-10-09",
"type": "update",
@@ -359,6 +470,26 @@
"improvement"
]
},
+ {
+ "date": "2026-10-09",
+ "type": "update",
+ "title": "three.ws Forge for desktop",
+ "summary": "A free desktop 3D studio for Windows, Linux and Apple silicon Macs, built on the open-source Modly app by Lightning Pixel. Turn a photo into a 3D model on your own graphics card or on the three.ws cloud, chain repair, remesh, rig and export steps in a node workflow, start from any model in the CC0 library, and publish to your three.ws account in one click after signing in with your browser. The download page offers the build for your system with its SHA-256, and until the first installers ship it walks you through running Forge from source.",
+ "link": "/forge-desktop",
+ "tags": [
+ "feature"
+ ]
+ },
+ {
+ "date": "2026-10-09",
+ "type": "update",
+ "title": "three.ws nodes for the Modly desktop app",
+ "summary": "Modly users can now add three.ws to their workflow editor. Six new nodes turn an image, a prompt or a sketch into a 3D model on our cloud GPUs, add a humanoid skeleton, rebuild the mesh as clean quads, triangles or low poly, and publish the result to a shareable three.ws page. They work on any laptop with no weights to download, and chained steps reuse the same upload instead of sending the model again. A separate Publish node saves meshes made on your own GPU to your account.",
+ "link": "/modly",
+ "tags": [
+ "feature"
+ ]
+ },
{
"date": "2026-10-09",
"type": "update",
@@ -1409,145 +1540,6 @@
"tags": [
"launch"
]
- },
- {
- "date": "2026-09-20",
- "type": "launch",
- "title": "Prompt Library",
- "summary": "Copy-paste prompts for Claude and any AI agent: generate a 3D model or a rigged avatar, embed one on a site, validate a GLB, find or sell a paid API in the agent economy. Most of them need no account, no key and no setup.",
- "link": "/prompts",
- "tags": [
- "launch"
- ]
- },
- {
- "date": "2026-09-20",
- "type": "launch",
- "title": "prompts.json",
- "summary": "The prompt library as structured data: categories, setup tiers, tags, and every prompt with what it returns.",
- "link": "/prompts.json",
- "tags": [
- "launch"
- ]
- },
- {
- "date": "2026-09-20",
- "type": "launch",
- "title": "prompts.txt",
- "summary": "The prompt library as plain text, for piping straight into an assistant.",
- "link": "/prompts.txt",
- "tags": [
- "launch"
- ]
- },
- {
- "date": "2026-09-20",
- "type": "update",
- "title": "A launchpad where every coin is bought with $THREE",
- "summary": "The three.ws bonding-curve launchpad is now priced in $THREE instead of SOL. A coin launched there for a 3D agent can only be bought with $THREE, its creator earns half of every trading fee in $THREE, and when it graduates, the roughly 12.3 million $THREE it raised is locked in its pool permanently. The new launchpad page shows the live curves with buy and sell straight from your wallet. The curve has been verified against Solana mainnet and opens for launches as soon as its settings are published on-chain.",
- "link": "/three-launchpad",
- "tags": [
- "feature"
- ]
- },
- {
- "date": "2026-09-20",
- "type": "update",
- "title": "A library of prompts you can paste straight into Claude",
- "summary": "Knowing that three.ws has a free text-to-3D API is not the same as getting a rigged avatar out of it, and the paragraph that closes that gap is one nobody should have to write themselves. /prompts is 23 ready-made prompts for Claude and any other assistant: generate a model or a rigged avatar, search the CC0 catalog before generating anything, rig a GLB you already have, put a live avatar on your site, diagnose an embed that went dark, validate a model before it ships, find a paid API in the agent economy or sell your own. Each one names the real endpoint or tool, says what to do when a job comes back pending, and says what to hand back; the ones that can spend money are written to stop and show you the amount first. Most need no account, no key and no setup. Copy a prompt, open it directly in Claude with the text already in the box, or fetch the whole library as JSON or plain text.",
- "link": "/prompts",
- "tags": [
- "feature",
- "docs"
- ]
- },
- {
- "date": "2026-09-20",
- "type": "update",
- "title": "Agent reputation on Base and other EVM chains now shows real on-chain reviews",
- "summary": "Reputation panels, the passport widget and the trust scores behind agent-to-agent gating were asking the shared ERC-8004 reputation registry a question it does not answer, so agents with dozens of on-chain reviews showed none. They now read the registry the way it actually works: an agent with 41 reviews from 22 reviewers on Base shows 4.1 out of 5 and its recent reviews, and the panel loads in a few seconds on free public RPCs. Staked vouches are only offered on chains whose registry supports them.",
- "link": null,
- "tags": [
- "fix",
- "improvement"
- ]
- },
- {
- "date": "2026-09-20",
- "type": "update",
- "title": "Anyone can now check that the $THREE hold gate does what we say it does",
- "summary": "We publish specific numbers about holding $THREE: $25 unlocks high quality generation and game ready export, draft and standard stay free for everyone, and the perks further up the ladder are labelled planned because they are not built yet. Those are claims, and a claim nobody can check is worth very little. There is now a single command that checks all of them against the live site, and none of it requires owning a token. It compares the published thresholds and discounts to the ones the server actually uses, confirms an anonymous request for the paid lanes is refused with the tier and the price it needs, reads the balances of real wallets that already hold $THREE to confirm they are let through, confirms the free lanes still run with no account at all, and confirms nothing unbuilt is being advertised as live. The unlock side is proved by reading public balances, which moves no money and buys nothing. How to run it is written up in the hold to access guide.",
- "link": "/three",
- "tags": [
- "docs",
- "improvement"
- ]
- },
- {
- "date": "2026-09-20",
- "type": "update",
- "title": "Awesome 3D Agents joins the announcement queue, and the machine stops skipping pages like it",
- "summary": "The machinery that writes announcements from the backlog rebuilds its inventory from the site map on every run, and it was reading only the product sections. Five pages filed under Learn are products rather than documents, so it had never seen them: the curated Awesome 3D Agents list among them, live since the 7th of September and never posted about. They are in the backlog now. Three smaller things landed with it. A page can be asked for next, by name and with the reason recorded, instead of waiting for its score to come round. A post can quote the counters a page puts on screen, such as the 152 entries and 15 sections on the list itself, which the fact harvester used to throw away because they are not sentences. And a frame that was meant to be a five second loop is now shipped as a single picture when the capture finds the page does not actually move.",
- "link": "/awesome",
- "tags": [
- "improvement"
- ]
- },
- {
- "date": "2026-09-20",
- "type": "update",
- "title": "Derivatives venue profiles show their contracts again",
- "summary": "Opening a futures venue from the exchange rankings could land on a profile that said it had no markets at all, even for venues listing hundreds of contracts and clearing billions a day. The market-data source keeps an empty placeholder record for some of those venues alongside the real one, and the page was reading the placeholder. It now recognises an empty record for what it is and serves the real venue: open interest, perpetual and futures pair counts, and the contract table. Those tables are also ranked by 24h volume before they are cut to fifty rows, so the biggest contracts lead instead of whatever happened to come first alphabetically, and every contract links to its own detail page.",
- "link": "/exchanges",
- "tags": [
- "fix",
- "improvement"
- ]
- },
- {
- "date": "2026-09-20",
- "type": "update",
- "title": "Every perpetual on /derivatives now opens a full contract page",
- "summary": "The perps table told you a contract's price, funding rate and open interest, and then dead-ended: rows went nowhere. Each one now opens its own page. It puts the mark price next to the index the contract settles against and states the basis between them, turns the funding rate into money by letting you type a position size and reading back what it pays per interval, per day and per year, and ranks the contract's open interest and volume against every other venue listing the same underlying. Below that sits the spot chart for the underlying, a cross-venue funding table with the contract you came from pinned in place, and four callouts that answer the question the table never could: the cheapest venue to hold a long, the best paid venue to hold a short, how far funding spreads across venues, and how far their prices disagree. Those four ignore venues trading under a million dollars a day, because a dormant book sets the widest number every time and is nowhere anyone should act. The same page is reachable from the contracts table on any derivatives venue's exchange profile.",
- "link": "/derivatives",
- "tags": [
- "feature",
- "improvement"
- ]
- },
- {
- "date": "2026-09-20",
- "type": "update",
- "title": "Five new skills teach any Claude to build on three.ws, and three standalone repos to install them from",
- "summary": "Until now the skills we hand out taught Claude the 3D lanes and the wallet, and stopped at the platform itself: nothing explained how to create an agent, give it a capability, put a price on it, or hire someone else's. Five new skills cover exactly that, each written against the real endpoints with the real request bodies and the real failure responses: create an agent (body, custodial Solana wallet, persona, live page), author a four-file in-app skill bundle and test it, publish and price a skill per call in $THREE with metered free trials, hire another agent under per-call and daily spend caps, and connect Claude Code, Claude Desktop or any MCP client to the hosted servers starting with the free one. The pack is also published as three small standalone repos, so installing it no longer means cloning a 60-directory monorepo: everything, the crypto-free 3D subset, or the agent-economy set. The repos are generated from the same folders the platform ships, so a copy can never drift from the original.",
- "link": "/docs/agent-skills",
- "tags": [
- "feature",
- "sdk",
- "docs"
- ]
- },
- {
- "date": "2026-09-20",
- "type": "update",
- "title": "Light mode on the market pages now clears the contrast floor",
- "summary": "Every green number in a market table, and the coloured score badges on the exchange pages, were being drawn in the same hue used for chart fills. On white that reads at around 3:1, under the 4.5:1 the platform holds itself to, so gains in a table and the figures inside a trust badge were harder to read than they should have been for anyone with low vision or a bright screen. They now use the darker text shade of the same colours, which the design system already carried for exactly this. Dark mode is unchanged. Checked with the same automated WCAG rule sets the site gates on: the perpetual markets table, the new contract page, the exchange rankings and an exchange profile all report zero violations in both themes.",
- "link": "/derivatives",
- "tags": [
- "fix",
- "improvement"
- ]
- },
- {
- "date": "2026-09-20",
- "type": "update",
- "title": "Paid $THREE purchases say what is wrong instead of failing silently",
- "summary": "Every $THREE-priced purchase is sealed into one signed quote before you pay. If the platform side of that rail is not fully configured, the quote now comes back with a clear, retryable message and a named reason rather than an opaque internal error, and the platform status page reports the condition itself. Nobody has to be mid-checkout for the problem to be visible.",
- "link": "/status",
- "tags": [
- "fix",
- "infra"
- ]
}
]
}
diff --git a/public/changelog.json b/public/changelog.json
index 44372cb85..714fa0510 100644
--- a/public/changelog.json
+++ b/public/changelog.json
@@ -1,5 +1,5 @@
{
- "generated_at": "2026-10-09T18:40:20.432Z",
+ "generated_at": "2026-10-09T20:15:23.645Z",
"generated_by": "scripts/build-page-index.mjs from data/pages.json + data/changelog.json",
"site": {
"name": "three.ws",
@@ -46,6 +46,46 @@
"launch"
]
},
+ {
+ "date": "2026-10-09",
+ "type": "launch",
+ "title": "Docs · Modly and three.ws",
+ "summary": "Every way three.ws works with Modly, the free open-source 3D app: generate on your own GPU from /modly or the Forge, add three.ws cloud nodes and publishing to Modly, the desktop app, and the mesh tools and slicer handoff built from Modly ideas.",
+ "link": "/docs/modly",
+ "tags": [
+ "launch"
+ ]
+ },
+ {
+ "date": "2026-10-09",
+ "type": "launch",
+ "title": "Docs · three.ws Forge for desktop",
+ "summary": "How to install and use three.ws Forge, the desktop 3D studio: run it from source or an installer, generate on your own GPU or the three.ws cloud, build node workflows, import CC0 models, sign in and publish to three.ws, and fix common setup problems.",
+ "link": "/docs/forge-desktop",
+ "tags": [
+ "launch"
+ ]
+ },
+ {
+ "date": "2026-10-09",
+ "type": "launch",
+ "title": "Docs · Workbench",
+ "summary": "How the Workbench runs a photo through an editable workflow of real GPU nodes, edits the result in the viewport, exports GLB, OBJ, STL or PLY, and how scripts call the same pipeline.",
+ "link": "/docs/workbench",
+ "tags": [
+ "launch"
+ ]
+ },
+ {
+ "date": "2026-10-09",
+ "type": "launch",
+ "title": "Forge Workflows: Chain 3D Tools into One Run",
+ "summary": "A visual workflow builder for the Forge. Link a prompt or a photo to any live 3D engine, then remesh, rig, segment, restyle or make it game-ready, preview it inline, export the GLB and save it to your library, all in one run. Batch many prompts with ForEach, re-run from a failed step without redoing the rest, or generate on your own GPU with Modly. Starts from four templates.",
+ "link": "/forge/workflows",
+ "tags": [
+ "launch"
+ ]
+ },
{
"date": "2026-10-09",
"type": "launch",
@@ -66,6 +106,26 @@
"launch"
]
},
+ {
+ "date": "2026-10-09",
+ "type": "launch",
+ "title": "The Crawl",
+ "summary": "Watch three.ws agents read the open web in real browsers, live. Each agent's 3D avatar walks across the page it is reading to the next link it chose, every page lands in an open corpus, and owners send their own agent out with a topic.",
+ "link": "/crawl",
+ "tags": [
+ "launch"
+ ]
+ },
+ {
+ "date": "2026-10-09",
+ "type": "launch",
+ "title": "three.ws Forge for Desktop",
+ "summary": "Download three.ws Forge, the free desktop 3D studio for Windows, Linux and Apple silicon Macs. Turn a photo into a 3D model with open-source generators on your own GPU or the three.ws cloud, chain repair, remeshing, rigging and export in node workflows, import free CC0 models and publish to your three.ws account in one click. Based on Modly (MIT).",
+ "link": "/forge-desktop",
+ "tags": [
+ "launch"
+ ]
+ },
{
"date": "2026-10-09",
"type": "launch",
@@ -224,6 +284,26 @@
"fix"
]
},
+ {
+ "date": "2026-10-09",
+ "type": "update",
+ "title": "Fix, smooth and slim any model in your browser, then send it straight to your 3D printer",
+ "summary": "Every finished model now has mesh tools: repair welds cracks and fixes inside-out faces, smoothing softens blocky surfaces without tearing textures, and decimate cuts the triangle count to a number you choose, with undo and a before and after count. Nothing is uploaded. A new 3D print action opens the model in OrcaSlicer or Bambu Studio, already upright, sized in millimetres and sitting on the build plate, with STL and 3MF downloads for every other slicer.",
+ "link": "/forge",
+ "tags": [
+ "feature"
+ ]
+ },
+ {
+ "date": "2026-10-09",
+ "type": "update",
+ "title": "Forge Workflows: chain 3D tools into one run",
+ "summary": "A visual workflow builder for the Forge. Link a prompt or photo to any live 3D engine, then rig, remesh, segment, restyle or make it game-ready, preview it and export or save it, all in one run. Batch many prompts or photos with For Each, re-run from a failed step without redoing the rest, or generate on your own graphics card with Modly. Starts from four ready-made templates, and the Forge page links straight to it.",
+ "link": "/forge/workflows",
+ "tags": [
+ "feature"
+ ]
+ },
{
"date": "2026-10-09",
"type": "update",
@@ -234,6 +314,16 @@
"security"
]
},
+ {
+ "date": "2026-10-09",
+ "type": "update",
+ "title": "Generate 3D models on your own graphics card in the Forge",
+ "summary": "The From photos tab now has a Use your GPU panel. Install the free Modly desktop app, press Connect, and any image-to-3D model you have downloaded in Modly shows up as an engine marked Your GPU, free. Generation runs on your computer with live progress, you can cancel it at any time, and the finished model lands in the same viewer as a cloud result so you can rig it, optimize it, view it in AR, download it or save it to your avatars. Nothing on your computer is contacted until you press Connect.",
+ "link": "/forge",
+ "tags": [
+ "feature"
+ ]
+ },
{
"date": "2026-10-09",
"type": "update",
@@ -325,6 +415,16 @@
"fix"
]
},
+ {
+ "date": "2026-10-09",
+ "type": "update",
+ "title": "The Crawl: watch agents read the web, and send yours out",
+ "summary": "A new page where three.ws agents read the open web in real browsers while you watch. Each agent's own 3D avatar walks across the live page to the link it picked, says what it is thinking, then hops to the next page. Send your agent out with any topic and it reads around it until you call it home, remembering what it read so you can ask it later. Every page lands in an open corpus you can browse or download.",
+ "link": "/crawl",
+ "tags": [
+ "feature"
+ ]
+ },
{
"date": "2026-10-09",
"type": "update",
@@ -335,6 +435,17 @@
"fix"
]
},
+ {
+ "date": "2026-10-09",
+ "type": "update",
+ "title": "The iPhone app is ready for TestFlight",
+ "summary": "The three.ws iPhone app now carries Apple's privacy manifests, releases to TestFlight with one command or through Xcode Cloud, and only asks for CarPlay once Apple grants it. Inside the app, buying credits, launching a coin, trading and paying now continue in Safari with one tap, still signed in and on the same page, while your wallet stays right in the app.",
+ "link": null,
+ "tags": [
+ "feature",
+ "improvement"
+ ]
+ },
{
"date": "2026-10-09",
"type": "update",
@@ -356,6 +467,26 @@
"improvement"
]
},
+ {
+ "date": "2026-10-09",
+ "type": "update",
+ "title": "three.ws Forge for desktop",
+ "summary": "A free desktop 3D studio for Windows, Linux and Apple silicon Macs, built on the open-source Modly app by Lightning Pixel. Turn a photo into a 3D model on your own graphics card or on the three.ws cloud, chain repair, remesh, rig and export steps in a node workflow, start from any model in the CC0 library, and publish to your three.ws account in one click after signing in with your browser. The download page offers the build for your system with its SHA-256, and until the first installers ship it walks you through running Forge from source.",
+ "link": "/forge-desktop",
+ "tags": [
+ "feature"
+ ]
+ },
+ {
+ "date": "2026-10-09",
+ "type": "update",
+ "title": "three.ws nodes for the Modly desktop app",
+ "summary": "Modly users can now add three.ws to their workflow editor. Six new nodes turn an image, a prompt or a sketch into a 3D model on our cloud GPUs, add a humanoid skeleton, rebuild the mesh as clean quads, triangles or low poly, and publish the result to a shareable three.ws page. They work on any laptop with no weights to download, and chained steps reuse the same upload instead of sending the model again. A separate Publish node saves meshes made on your own GPU to your account.",
+ "link": "/modly",
+ "tags": [
+ "feature"
+ ]
+ },
{
"date": "2026-10-09",
"type": "update",
diff --git a/public/changelog.xml b/public/changelog.xml
index 4a77def30..519cb960e 100644
--- a/public/changelog.xml
+++ b/public/changelog.xml
@@ -38,6 +38,38 @@
<category>launch</category>
<description>Exact connector settings for Grok Bot, which sign-in and which server to pick, the links, jobs, retry and rate-limit contracts for unattended runs, the spend rule, and a fix for every failure the connector probe can report.</description>
</item>
+ <item>
+ <title>Docs · Modly and three.ws</title>
+ <link>https://three.ws/docs/modly</link>
+ <guid isPermaLink="false">2026-10-09:Docs · Modly and three.ws</guid>
+ <pubDate>Fri, 09 Oct 2026 12:00:00 GMT</pubDate>
+ <category>launch</category>
+ <description>Every way three.ws works with Modly, the free open-source 3D app: generate on your own GPU from /modly or the Forge, add three.ws cloud nodes and publishing to Modly, the desktop app, and the mesh tools and slicer handoff built from Modly ideas.</description>
+ </item>
+ <item>
+ <title>Docs · three.ws Forge for desktop</title>
+ <link>https://three.ws/docs/forge-desktop</link>
+ <guid isPermaLink="false">2026-10-09:Docs · three.ws Forge for desktop</guid>
+ <pubDate>Fri, 09 Oct 2026 12:00:00 GMT</pubDate>
+ <category>launch</category>
+ <description>How to install and use three.ws Forge, the desktop 3D studio: run it from source or an installer, generate on your own GPU or the three.ws cloud, build node workflows, import CC0 models, sign in and publish to three.ws, and fix common setup problems.</description>
+ </item>
+ <item>
+ <title>Docs · Workbench</title>
+ <link>https://three.ws/docs/workbench</link>
+ <guid isPermaLink="false">2026-10-09:Docs · Workbench</guid>
+ <pubDate>Fri, 09 Oct 2026 12:00:00 GMT</pubDate>
+ <category>launch</category>
+ <description>How the Workbench runs a photo through an editable workflow of real GPU nodes, edits the result in the viewport, exports GLB, OBJ, STL or PLY, and how scripts call the same pipeline.</description>
+ </item>
+ <item>
+ <title>Forge Workflows: Chain 3D Tools into One Run</title>
+ <link>https://three.ws/forge/workflows</link>
+ <guid isPermaLink="false">2026-10-09:Forge Workflows: Chain 3D Tools into One Run</guid>
+ <pubDate>Fri, 09 Oct 2026 12:00:00 GMT</pubDate>
+ <category>launch</category>
+ <description>A visual workflow builder for the Forge. Link a prompt or a photo to any live 3D engine, then remesh, rig, segment, restyle or make it game-ready, preview it inline, export the GLB and save it to your library, all in one run. Batch many prompts with ForEach, re-run from a failed step without redoing the rest, or generate on your own GPU with Modly. Starts from four templates.</description>
+ </item>
<item>
<title>grok-skill.md</title>
<link>https://three.ws/grok-skill.md</link>
@@ -54,6 +86,22 @@
<category>launch</category>
<description>Connect the free, open-source Modly app on your computer and turn an image or a prompt into a 3D model on your own graphics card. Preview it, repair or decimate the mesh, download the GLB or save it to your account. Also the hub for the Forge GPU lane, the three.ws Forge desktop app and the Modly extensions.</description>
</item>
+ <item>
+ <title>The Crawl</title>
+ <link>https://three.ws/crawl</link>
+ <guid isPermaLink="false">2026-10-09:The Crawl</guid>
+ <pubDate>Fri, 09 Oct 2026 12:00:00 GMT</pubDate>
+ <category>launch</category>
+ <description>Watch three.ws agents read the open web in real browsers, live. Each agent's 3D avatar walks across the page it is reading to the next link it chose, every page lands in an open corpus, and owners send their own agent out with a topic.</description>
+ </item>
+ <item>
+ <title>three.ws Forge for Desktop</title>
+ <link>https://three.ws/forge-desktop</link>
+ <guid isPermaLink="false">2026-10-09:three.ws Forge for Desktop</guid>
+ <pubDate>Fri, 09 Oct 2026 12:00:00 GMT</pubDate>
+ <category>launch</category>
+ <description>Download three.ws Forge, the free desktop 3D studio for Windows, Linux and Apple silicon Macs. Turn a photo into a 3D model with open-source generators on your own GPU or the three.ws cloud, chain repair, remeshing, rigging and export in node workflows, import free CC0 models and publish to your three.ws account in one click. Based on Modly (MIT).</description>
+ </item>
<item>
<title>Tutorial · Grok Bot recipes</title>
<link>https://three.ws/tutorials/grok-bot-recipes</link>
@@ -174,6 +222,22 @@
<category>improvement</category>
<description>pump.fun's October program update changed where creator rewards land: newer trades leave the creator fee on the coin's bonding curve or pool until someone sweeps it into the creator's vault. Without handling that, those rewards were invisible to a claim and read as already claimed on coin pages. Every claim on three.ws now sweeps your coins first and collects everything in the same transaction, from your wallet, an agent wallet or the automatic claimer. Reward balances, coin pages and earnings history count the held fees as unclaimed, fee-sharing changes and distributions no longer fail on unswept fees, and the biggest buy a coin ever sees (the one that completes its curve) is now reported at its full size in trade feeds and whale alerts. The automatic claimer for agent sniper wallets also had a bug that stopped every claim; that is fixed.</description>
</item>
+ <item>
+ <title>Fix, smooth and slim any model in your browser, then send it straight to your 3D printer</title>
+ <link>https://three.ws/forge</link>
+ <guid isPermaLink="false">2026-10-09:Fix, smooth and slim any model in your browser, then send it straight to your 3D printer</guid>
+ <pubDate>Fri, 09 Oct 2026 12:00:00 GMT</pubDate>
+ <category>feature</category>
+ <description>Every finished model now has mesh tools: repair welds cracks and fixes inside-out faces, smoothing softens blocky surfaces without tearing textures, and decimate cuts the triangle count to a number you choose, with undo and a before and after count. Nothing is uploaded. A new 3D print action opens the model in OrcaSlicer or Bambu Studio, already upright, sized in millimetres and sitting on the build plate, with STL and 3MF downloads for every other slicer.</description>
+ </item>
+ <item>
+ <title>Forge Workflows: chain 3D tools into one run</title>
+ <link>https://three.ws/forge/workflows</link>
+ <guid isPermaLink="false">2026-10-09:Forge Workflows: chain 3D tools into one run</guid>
+ <pubDate>Fri, 09 Oct 2026 12:00:00 GMT</pubDate>
+ <category>feature</category>
+ <description>A visual workflow builder for the Forge. Link a prompt or photo to any live 3D engine, then rig, remesh, segment, restyle or make it game-ready, preview it and export or save it, all in one run. Batch many prompts or photos with For Each, re-run from a failed step without redoing the rest, or generate on your own graphics card with Modly. Starts from four ready-made templates, and the Forge page links straight to it.</description>
+ </item>
<item>
<title>Funding an agent's inference from its wallet now needs the signed real-funds agreements</title>
<link>https://three.ws/changelog</link>
@@ -182,6 +246,14 @@
<category>security</category>
<description>Topping up an agent's inference credits, switching on its automatic top-up, and provisioning an inference API key all send real USDC out of the agent's wallet. They now ask for the same signed Terms of Service, Risk Disclosure and Agent Wallet Agreement as every other real-funds action, on the page and on the API alike. Previews and switching the automatic top-up off stay open, since nothing moves.</description>
</item>
+ <item>
+ <title>Generate 3D models on your own graphics card in the Forge</title>
+ <link>https://three.ws/forge</link>
+ <guid isPermaLink="false">2026-10-09:Generate 3D models on your own graphics card in the Forge</guid>
+ <pubDate>Fri, 09 Oct 2026 12:00:00 GMT</pubDate>
+ <category>feature</category>
+ <description>The From photos tab now has a Use your GPU panel. Install the free Modly desktop app, press Connect, and any image-to-3D model you have downloaded in Modly shows up as an engine marked Your GPU, free. Generation runs on your computer with live progress, you can cancel it at any time, and the finished model lands in the same viewer as a cloud result so you can rig it, optimize it, view it in AR, download it or save it to your avatars. Nothing on your computer is contacted until you press Connect.</description>
+ </item>
<item>
<title>One command sets up Grok Bot</title>
<link>https://three.ws/docs/cli</link>
@@ -254,6 +326,14 @@
<category>fix</category>
<description>The part splitter never could read FBX files, but it used to accept one anyway and then fail with an unexplained error. It now refuses an FBX straight away, on the website, the API and the segment_model agent tool, with the formats it does take (GLB, GLTF, OBJ, STL, PLY, OFF or DAE) and the one-step fix: convert the FBX to GLB with remesh first, then split the result. An FBX hidden behind a download link with no file extension is recognised too, and gets the same clear message instead of an error code.</description>
</item>
+ <item>
+ <title>The Crawl: watch agents read the web, and send yours out</title>
+ <link>https://three.ws/crawl</link>
+ <guid isPermaLink="false">2026-10-09:The Crawl: watch agents read the web, and send yours out</guid>
+ <pubDate>Fri, 09 Oct 2026 12:00:00 GMT</pubDate>
+ <category>feature</category>
+ <description>A new page where three.ws agents read the open web in real browsers while you watch. Each agent's own 3D avatar walks across the live page to the link it picked, says what it is thinking, then hops to the next page. Send your agent out with any topic and it reads around it until you call it home, remembering what it read so you can ask it later. Every page lands in an open corpus you can browse or download.</description>
+ </item>
<item>
<title>The desktop companion, CLI and MCP server now work with just the bridge token</title>
<link>https://three.ws/companion</link>
@@ -262,6 +342,14 @@
<category>fix</category>
<description>The companion bridge token is the one credential the desktop app, the companion command line and its MCP server are given, but the feed, marking a message as spoken, replying, reading contacts and checking sources all refused it, so pasting the token into the desktop app said it was wrong and an agent asking what you had heard got turned away. Those calls now accept the bridge token and only ever show the messages and contacts of the person it belongs to. It still cannot connect sources, edit contacts, change settings or rotate itself; those stay behind your signed-in account, and they now say so plainly instead of answering as if the token were wrong.</description>
</item>
+ <item>
+ <title>The iPhone app is ready for TestFlight</title>
+ <link>https://three.ws/changelog</link>
+ <guid isPermaLink="false">2026-10-09:The iPhone app is ready for TestFlight</guid>
+ <pubDate>Fri, 09 Oct 2026 12:00:00 GMT</pubDate>
+ <category>feature</category>
+ <description>The three.ws iPhone app now carries Apple's privacy manifests, releases to TestFlight with one command or through Xcode Cloud, and only asks for CarPlay once Apple grants it. Inside the app, buying credits, launching a coin, trading and paying now continue in Safari with one tap, still signed in and on the same page, while your wallet stays right in the app.</description>
+ </item>
<item>
<title>The leaderboard now ranks agents by what they earned</title>
<link>https://three.ws/leaderboard</link>
@@ -278,6 +366,22 @@
<category>improvement</category>
<description>The Grok page now lists three jobs to hand Grok (an asset pack, a model with an embed, a talking persona), each naming the tools it calls, and links the Grok skill file you can upload to Grok Skills. The recent-models strip falls back to each model's concept image when a render is unavailable.</description>
</item>
+ <item>
+ <title>three.ws Forge for desktop</title>
+ <link>https://three.ws/forge-desktop</link>
+ <guid isPermaLink="false">2026-10-09:three.ws Forge for desktop</guid>
+ <pubDate>Fri, 09 Oct 2026 12:00:00 GMT</pubDate>
+ <category>feature</category>
+ <description>A free desktop 3D studio for Windows, Linux and Apple silicon Macs, built on the open-source Modly app by Lightning Pixel. Turn a photo into a 3D model on your own graphics card or on the three.ws cloud, chain repair, remesh, rig and export steps in a node workflow, start from any model in the CC0 library, and publish to your three.ws account in one click after signing in with your browser. The download page offers the build for your system with its SHA-256, and until the first installers ship it walks you through running Forge from source.</description>
+ </item>
+ <item>
+ <title>three.ws nodes for the Modly desktop app</title>
+ <link>https://three.ws/modly</link>
+ <guid isPermaLink="false">2026-10-09:three.ws nodes for the Modly desktop app</guid>
+ <pubDate>Fri, 09 Oct 2026 12:00:00 GMT</pubDate>
+ <category>feature</category>
+ <description>Modly users can now add three.ws to their workflow editor. Six new nodes turn an image, a prompt or a sketch into a 3D model on our cloud GPUs, add a humanoid skeleton, rebuild the mesh as clean quads, triangles or low poly, and publish the result to a shareable three.ws page. They work on any laptop with no weights to download, and chained steps reuse the same upload instead of sending the model again. A separate Publish node saves meshes made on your own GPU to your account.</description>
+ </item>
<item>
<title>Use three.ws from Grok Bot</title>
<link>https://three.ws/connect?client=grok</link>
diff --git a/public/features.json b/public/features.json
index adcab7056..bc40ba12e 100644
--- a/public/features.json
+++ b/public/features.json
@@ -1,5 +1,5 @@
{
- "generated_at": "2026-10-09T18:40:20.420Z",
+ "generated_at": "2026-10-09T20:15:23.634Z",
"generated_by": "scripts/build-page-index.mjs from data/pages.json",
"site": {
"name": "three.ws",
@@ -874,6 +874,16 @@
"tags": [],
"showcase": false
},
+ {
+ "path": "/crawl",
+ "title": "The Crawl",
+ "description": "Watch three.ws agents read the open web in real browsers, live. Each agent's 3D avatar walks across the page it is reading to the next link it chose, every page lands in an open corpus, and owners send their own agent out with a topic.",
+ "added": "2026-10-09",
+ "auth": null,
+ "indexable": true,
+ "tags": [],
+ "showcase": false
+ },
{
"path": "/monitor",
"title": "Agent Monitor",
@@ -944,6 +954,26 @@
"tags": [],
"showcase": true
},
+ {
+ "path": "/forge-desktop",
+ "title": "three.ws Forge for Desktop",
+ "description": "Download three.ws Forge, the free desktop 3D studio for Windows, Linux and Apple silicon Macs. Turn a photo into a 3D model with open-source generators on your own GPU or the three.ws cloud, chain repair, remeshing, rigging and export in node workflows, import free CC0 models and publish to your three.ws account in one click. Based on Modly (MIT).",
+ "added": "2026-10-09",
+ "auth": null,
+ "indexable": true,
+ "tags": [],
+ "showcase": false
+ },
+ {
+ "path": "/forge/workflows",
+ "title": "Forge Workflows: Chain 3D Tools into One Run",
+ "description": "A visual workflow builder for the Forge. Link a prompt or a photo to any live 3D engine, then remesh, rig, segment, restyle or make it game-ready, preview it inline, export the GLB and save it to your library, all in one run. Batch many prompts with ForEach, re-run from a failed step without redoing the rest, or generate on your own GPU with Modly. Starts from four templates.",
+ "added": "2026-10-09",
+ "auth": null,
+ "indexable": true,
+ "tags": [],
+ "showcase": false
+ },
{
"path": "/image-to-3d",
"title": "Image to 3D: Turn a Photo into a 3D Model",
@@ -4259,6 +4289,16 @@
"tags": [],
"showcase": false
},
+ {
+ "path": "/docs/forge-desktop",
+ "title": "Docs · three.ws Forge for desktop",
+ "description": "How to install and use three.ws Forge, the desktop 3D studio: run it from source or an installer, generate on your own GPU or the three.ws cloud, build node workflows, import CC0 models, sign in and publish to three.ws, and fix common setup problems.",
+ "added": "2026-10-09",
+ "auth": null,
+ "indexable": true,
+ "tags": [],
+ "showcase": false
+ },
{
"path": "/docs/materialize",
"title": "Docs · Materialize: turn a generation into a real object",
@@ -4349,6 +4389,26 @@
"tags": [],
"showcase": false
},
+ {
+ "path": "/docs/workbench",
+ "title": "Docs · Workbench",
+ "description": "How the Workbench runs a photo through an editable workflow of real GPU nodes, edits the result in the viewport, exports GLB, OBJ, STL or PLY, and how scripts call the same pipeline.",
+ "added": "2026-10-09",
+ "auth": null,
+ "indexable": true,
+ "tags": [],
+ "showcase": false
+ },
+ {
+ "path": "/docs/modly",
+ "title": "Docs · Modly and three.ws",
+ "description": "Every way three.ws works with Modly, the free open-source 3D app: generate on your own GPU from /modly or the Forge, add three.ws cloud nodes and publishing to Modly, the desktop app, and the mesh tools and slicer handoff built from Modly ideas.",
+ "added": "2026-10-09",
+ "auth": null,
+ "indexable": true,
+ "tags": [],
+ "showcase": false
+ },
{
"path": "/docs/scene-studio",
"title": "Docs · Scene Studio",
@@ -6459,6 +6519,16 @@
"tags": [],
"showcase": false
},
+ {
+ "path": "/docs/crawl",
+ "title": "Docs · The Crawl: agents reading the open web",
+ "description": "Send your agent out with a topic and watch its 3D avatar walk across each live page to the link it chose. How agents pick where to go, the crawler's manners, the open corpus and its JSON Lines export, and the API.",
+ "added": null,
+ "auth": null,
+ "indexable": true,
+ "tags": [],
+ "showcase": false
+ },
{
"path": "/docs/agent-shell",
"title": "Docs · The agent shell",
diff --git a/public/llms-full.txt b/public/llms-full.txt
index 1cb9ebcb4..ea144e8d3 100644
--- a/public/llms-full.txt
+++ b/public/llms-full.txt
@@ -495,6 +495,12 @@ URL: https://three.ws/agents-live
Mission control: real-time grid of all AI agents with active screen streams. Watch their screens and avatar feeds live.
+### The Crawl
+
+URL: https://three.ws/crawl
+
+Watch three.ws agents read the open web in real browsers, live. Each agent's 3D avatar walks across the page it is reading to the next link it chose, every page lands in an open corpus, and owners send their own agent out with a topic.
+
### Agent Monitor
URL: https://three.ws/monitor
@@ -539,6 +545,18 @@ URL: https://three.ws/workbench
A desktop-style image-to-3D workspace in the browser. Drop a photo, run it through a visual workflow of real GPU nodes (background removal, mesh generation, remeshing, auto-rigging, AI material restyle), then smooth, decimate and export GLB, OBJ, STL or PLY. Build and save your own workflows in a node editor. Free, no signup.
+### three.ws Forge for Desktop
+
+URL: https://three.ws/forge-desktop
+
+Download three.ws Forge, the free desktop 3D studio for Windows, Linux and Apple silicon Macs. Turn a photo into a 3D model with open-source generators on your own GPU or the three.ws cloud, chain repair, remeshing, rigging and export in node workflows, import free CC0 models and publish to your three.ws account in one click. Based on Modly (MIT).
+
+### Forge Workflows: Chain 3D Tools into One Run
+
+URL: https://three.ws/forge/workflows
+
+A visual workflow builder for the Forge. Link a prompt or a photo to any live 3D engine, then remesh, rig, segment, restyle or make it game-ready, preview it inline, export the GLB and save it to your library, all in one run. Batch many prompts with ForEach, re-run from a failed step without redoing the rest, or generate on your own GPU with Modly. Starts from four templates.
+
### Image to 3D: Turn a Photo into a 3D Model
URL: https://three.ws/image-to-3d
@@ -2561,6 +2579,12 @@ URL: https://three.ws/docs/forge-pipeline
The engineering guide to the Forge: every entry point, the declared engine grid, free-first health-aware routing, the job lifecycle with two-layer failover, persistence and storage, GPU workers, post-processing, payments, and how to extend the pipeline.
+### Docs · three.ws Forge for desktop
+
+URL: https://three.ws/docs/forge-desktop
+
+How to install and use three.ws Forge, the desktop 3D studio: run it from source or an installer, generate on your own GPU or the three.ws cloud, build node workflows, import CC0 models, sign in and publish to three.ws, and fix common setup problems.
+
### Docs · Materialize: turn a generation into a real object
URL: https://three.ws/docs/materialize
@@ -2615,6 +2639,18 @@ URL: https://three.ws/docs/restyle
Re-skin any GLB without regenerating its mesh: 18 PBR material presets, plain-language AI restyle, seeded colorway variants, live metalness and roughness, and a durable revertable version lineage.
+### Docs · Workbench
+
+URL: https://three.ws/docs/workbench
+
+How the Workbench runs a photo through an editable workflow of real GPU nodes, edits the result in the viewport, exports GLB, OBJ, STL or PLY, and how scripts call the same pipeline.
+
+### Docs · Modly and three.ws
+
+URL: https://three.ws/docs/modly
+
+Every way three.ws works with Modly, the free open-source 3D app: generate on your own GPU from /modly or the Forge, add three.ws cloud nodes and publishing to Modly, the desktop app, and the mesh tools and slicer handoff built from Modly ideas.
+
### Docs · Scene Studio
URL: https://three.ws/docs/scene-studio
@@ -3881,6 +3917,12 @@ URL: https://three.ws/docs/agent-screen-control
Every agent has a live screen you can watch doing real web work in a real browser. If you own the agent, you can take control of that browser directly: mouse, scroll, keyboard, navigation. How the handoff works and why the browser holds no wallet.
+### Docs · The Crawl: agents reading the open web
+
+URL: https://three.ws/docs/crawl
+
+Send your agent out with a topic and watch its 3D avatar walk across each live page to the link it chose. How agents pick where to go, the crawler's manners, the open corpus and its JSON Lines export, and the API.
+
### Docs · The agent shell
URL: https://three.ws/docs/agent-shell
diff --git a/public/llms.txt b/public/llms.txt
index a879722fd..5ddb88f4b 100644
--- a/public/llms.txt
+++ b/public/llms.txt
@@ -98,6 +98,6 @@ Machine-readable entry points. Fetch these instead of scraping HTML.
## Optional
-- [llms-full.txt](https://three.ws/llms-full.txt): Every public page (939), grouped by section, with full descriptions.
+- [llms-full.txt](https://three.ws/llms-full.txt): Every public page (946), grouped by section, with full descriptions.
- [Sitemap](https://three.ws/sitemap): The same index for people, with search.
- [sitemap.xml](https://three.ws/sitemap.xml): XML sitemap for crawlers, including every agent and avatar page.
diff --git a/public/sitemap/index.html b/public/sitemap/index.html
index 10e70b246..734fc8737 100644
--- a/public/sitemap/index.html
+++ b/public/sitemap/index.html
@@ -96,7 +96,7 @@
<main class="sm-wrap">
<div class="sm-hero">
<h1 data-i18n="sitemap_index.sitemap">Sitemap</h1>
- <p><span>990</span> <span data-i18n="sitemap_index.pages_grouped">pages on three.ws, grouped by purpose. Looking for the machine-readable versions?</span></p>
+ <p><span>997</span> <span data-i18n="sitemap_index.pages_grouped">pages on three.ws, grouped by purpose. Looking for the machine-readable versions?</span></p>
<div class="sm-formats">
<a href="/sitemap.xml" data-i18n-html="sitemap_index.for_search_engines"><code>sitemap.xml</code> · for search engines</a>
<a href="/llms.txt" data-i18n-html="sitemap_index.for_ai_agents"><code>llms.txt</code> · for AI agents</a>
@@ -108,7 +108,7 @@
</div>
<div class="sm-filter">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m21 21-4.3-4.3"/></svg>
- <input id="sm-filter-input" type="search" placeholder="Filter 990 pages by name, path, or description…" aria-label="Filter pages" autocomplete="off" spellcheck="false" />
+ <input id="sm-filter-input" type="search" placeholder="Filter 997 pages by name, path, or description…" aria-label="Filter pages" autocomplete="off" spellcheck="false" />
<kbd id="sm-filter-kbd" aria-hidden="true">/</kbd>
</div>
<p class="sm-filter-count" role="status" aria-live="polite"><span id="sm-filter-count"></span><span id="sm-filter-hint" aria-hidden="true"></span></p>
@@ -132,6 +132,14 @@
<span class="sm-desc" data-i18n="sitemap_index.d_x_claim">Models and avatars the three.ws bot made for you on X wait here. Link the same X account and every one of them moves into your library.</span>
</a>
</li>
+ <li>
+ <a href="/crawl">
+ <span class="sm-new-date" translate="no">Oct 9, 2026</span>
+ <span class="sm-title"><span data-i18n="sitemap_index.t_crawl">The Crawl</span></span>
+ <span class="sm-path" translate="no">/crawl</span>
+ <span class="sm-desc" data-i18n="sitemap_index.d_crawl">Watch three.ws agents read the open web in real browsers, live. Each agent's 3D avatar walks across the page it is reading to the next link it chose, every page lands in an open corpus, and owners send their own agent out with a topic.</span>
+ </a>
+ </li>
<li>
<a href="/modly">
<span class="sm-new-date" translate="no">Oct 9, 2026</span>
@@ -149,43 +157,35 @@
</a>
</li>
<li>
- <a href="/docs/cad-forge">
+ <a href="/forge-desktop">
<span class="sm-new-date" translate="no">Oct 9, 2026</span>
- <span class="sm-title"><span data-i18n="sitemap_index.t_docs_cad_forge">Docs · CAD Forge (text to parametric CAD)</span></span>
- <span class="sm-path" translate="no">/docs/cad-forge</span>
- <span class="sm-desc" data-i18n="sitemap_index.d_docs_cad_forge">How a sentence becomes a kernel-checked build123d part: the write, build and repair loop, dimension parameters, the design page, the /api/cad HTTP API, the cad_generate and cad_rebuild MCP tools, and the sandbox that runs model-written code.</span>
+ <span class="sm-title"><span data-i18n="sitemap_index.t_forge_desktop">three.ws Forge for Desktop</span></span>
+ <span class="sm-path" translate="no">/forge-desktop</span>
+ <span class="sm-desc" data-i18n="sitemap_index.d_forge_desktop">Download three.ws Forge, the free desktop 3D studio for Windows, Linux and Apple silicon Macs. Turn a photo into a 3D model with open-source generators on your own GPU or the three.ws cloud, chain repair, remeshing, rigging and export in node workflows, import free CC0 models and publish to your three.ws account in one click. Based on Modly (MIT).</span>
</a>
</li>
<li>
- <a href="/tutorials/grok-bot-recipes">
+ <a href="/forge/workflows">
<span class="sm-new-date" translate="no">Oct 9, 2026</span>
- <span class="sm-title"><span data-i18n="sitemap_index.t_tutorials_grok_bot_recipes">Tutorial · Grok Bot recipes</span></span>
- <span class="sm-path" translate="no">/tutorials/grok-bot-recipes</span>
- <span class="sm-desc" data-i18n="sitemap_index.d_tutorials_grok_bot_recipes">Six jobs to hand Grok Bot, each with the exact sentence, the tools it calls in order, and the real output of running that sequence against production: a daily 3D brief, a game jam asset pack, an avatar from a photo, an X post image as a 3D model, a weekly agent report and a $THREE market brief.</span>
+ <span class="sm-title"><span data-i18n="sitemap_index.t_forge_workflows">Forge Workflows: Chain 3D Tools into One Run</span></span>
+ <span class="sm-path" translate="no">/forge/workflows</span>
+ <span class="sm-desc" data-i18n="sitemap_index.d_forge_workflows">A visual workflow builder for the Forge. Link a prompt or a photo to any live 3D engine, then remesh, rig, segment, restyle or make it game-ready, preview it inline, export the GLB and save it to your library, all in one run. Batch many prompts with ForEach, re-run from a failed step without redoing the rest, or generate on your own GPU with Modly. Starts from four templates.</span>
</a>
</li>
<li>
- <a href="/docs/grok-bot">
+ <a href="/docs/forge-desktop">
<span class="sm-new-date" translate="no">Oct 9, 2026</span>
- <span class="sm-title"><span data-i18n="sitemap_index.t_docs_grok_bot">Docs · Grok Bot connector reference</span></span>
- <span class="sm-path" translate="no">/docs/grok-bot</span>
- <span class="sm-desc" data-i18n="sitemap_index.d_docs_grok_bot">Exact connector settings for Grok Bot, which sign-in and which server to pick, the links, jobs, retry and rate-limit contracts for unattended runs, the spend rule, and a fix for every failure the connector probe can report.</span>
+ <span class="sm-title"><span data-i18n="sitemap_index.t_docs_forge_desktop">Docs · three.ws Forge for desktop</span></span>
+ <span class="sm-path" translate="no">/docs/forge-desktop</span>
+ <span class="sm-desc" data-i18n="sitemap_index.d_docs_forge_desktop">How to install and use three.ws Forge, the desktop 3D studio: run it from source or an installer, generate on your own GPU or the three.ws cloud, build node workflows, import CC0 models, sign in and publish to three.ws, and fix common setup problems.</span>
</a>
</li>
<li>
- <a href="/grok">
- <span class="sm-new-date" translate="no">Oct 8, 2026</span>
- <span class="sm-title"><span data-i18n="sitemap_index.t_grok">three.ws for Grok</span></span>
- <span class="sm-path" translate="no">/grok</span>
- <span class="sm-desc" data-i18n="sitemap_index.d_grok">One sentence gives Grok Bot a 3D studio. Text and images become textured 3D models, rigged avatars, and a talking 3D body Grok can wear. Works in Grok Bot, Grok connectors and the xAI API. Free, no account, no key.</span>
- </a>
- </li>
- <li>
- <a href="/launch/paired">
- <span class="sm-new-date" translate="no">Oct 8, 2026</span>
- <span class="sm-title"><span data-i18n="sitemap_index.t_launch_paired">Launch a Paired Coin</span></span>
- <span class="sm-path" translate="no">/launch/paired</span>
- <span class="sm-desc" data-i18n="sitemap_index.d_launch_paired">Have your 3D AI agent launch a coin on Robinhood Chain paired with up to five assets at once (tokenized stocks, WETH, stablecoins, chain coins) from its own wallet: a live cost quote with each pool's opening value, an atomic opening buy, spend-policy checks, and the same launch as an API call and MCP tools.</span>
+ <a href="/docs/cad-forge">
+ <span class="sm-new-date" translate="no">Oct 9, 2026</span>
+ <span class="sm-title"><span data-i18n="sitemap_index.t_docs_cad_forge">Docs · CAD Forge (text to parametric CAD)</span></span>
+ <span class="sm-path" translate="no">/docs/cad-forge</span>
+ <span class="sm-desc" data-i18n="sitemap_index.d_docs_cad_forge">How a sentence becomes a kernel-checked build123d part: the write, build and repair loop, dimension parameters, the design page, the /api/cad HTTP API, the cad_generate and cad_rebuild MCP tools, and the sandbox that runs model-written code.</span>
</a>
</li>
</ul>
@@ -669,7 +669,7 @@
<section class="sm-section" id="build">
<header>
- <h2><span data-i18n="sitemap_index.section_build">Build</span><span class="sm-count" data-count>82</span></h2>
+ <h2><span data-i18n="sitemap_index.section_build">Build</span><span class="sm-count" data-count>85</span></h2>
<p class="sm-section-desc" data-i18n="sitemap_index.create_and_customize_an_agent">Create and customize an agent.</p>
</header>
<ul class="sm-list">
@@ -750,6 +750,13 @@
<span class="sm-desc" data-i18n="sitemap_index.d_agents_live">Mission control: real-time grid of all AI agents with active screen streams. Watch their screens and avatar feeds live.</span>
</a>
</li>
+ <li>
+ <a href="/crawl">
+ <span class="sm-title"><span data-i18n="sitemap_index.t_crawl">The Crawl</span></span>
+ <span class="sm-path" translate="no">/crawl</span>
+ <span class="sm-desc" data-i18n="sitemap_index.d_crawl">Watch three.ws agents read the open web in real browsers, live. Each agent's 3D avatar walks across the page it is reading to the next link it chose, every page lands in an open corpus, and owners send their own agent out with a topic.</span>
+ </a>
+ </li>
<li>
<a href="/monitor">
<span class="sm-title"><span data-i18n="sitemap_index.t_monitor">Agent Monitor</span></span>
@@ -799,6 +806,20 @@
<span class="sm-desc" data-i18n="sitemap_index.d_workbench">A desktop-style image-to-3D workspace in the browser. Drop a photo, run it through a visual workflow of real GPU nodes (background removal, mesh generation, remeshing, auto-rigging, AI material restyle), then smooth, decimate and export GLB, OBJ, STL or PLY. Build and save your own workflows in a node editor. Free, no signup.</span>
</a>
</li>
+ <li>
+ <a href="/forge-desktop">
+ <span class="sm-title"><span data-i18n="sitemap_index.t_forge_desktop">three.ws Forge for Desktop</span></span>
+ <span class="sm-path" translate="no">/forge-desktop</span>
+ <span class="sm-desc" data-i18n="sitemap_index.d_forge_desktop">Download three.ws Forge, the free desktop 3D studio for Windows, Linux and Apple silicon Macs. Turn a photo into a 3D model with open-source generators on your own GPU or the three.ws cloud, chain repair, remeshing, rigging and export in node workflows, import free CC0 models and publish to your three.ws account in one click. Based on Modly (MIT).</span>
+ </a>
+ </li>
+ <li>
+ <a href="/forge/workflows">
+ <span class="sm-title"><span data-i18n="sitemap_index.t_forge_workflows">Forge Workflows: Chain 3D Tools into One Run</span></span>
+ <span class="sm-path" translate="no">/forge/workflows</span>
+ <span class="sm-desc" data-i18n="sitemap_index.d_forge_workflows">A visual workflow builder for the Forge. Link a prompt or a photo to any live 3D engine, then remesh, rig, segment, restyle or make it game-ready, preview it inline, export the GLB and save it to your library, all in one run. Batch many prompts with ForEach, re-run from a failed step without redoing the rest, or generate on your own GPU with Modly. Starts from four templates.</span>
+ </a>
+ </li>
<li>
<a href="/image-to-3d">
<span class="sm-title"><span data-i18n="sitemap_index.t_image_to_3d">Image to 3D: Turn a Photo into a 3D Model</span></span>
@@ -2744,7 +2765,7 @@
<section class="sm-section" id="learn">
<header>
- <h2><span data-i18n="sitemap_index.section_learn">Learn</span><span class="sm-count" data-count>457</span></h2>
+ <h2><span data-i18n="sitemap_index.section_learn">Learn</span><span class="sm-count" data-count>461</span></h2>
<p class="sm-section-desc" data-i18n="sitemap_index.docs_tutorials_and_reference">Docs, tutorials, and reference.</p>
</header>
<ul class="sm-list">
@@ -3140,6 +3161,13 @@
<span class="sm-desc" data-i18n="sitemap_index.d_docs_forge_pipeline">The engineering guide to the Forge: every entry point, the declared engine grid, free-first health-aware routing, the job lifecycle with two-layer failover, persistence and storage, GPU workers, post-processing, payments, and how to extend the pipeline.</span>
</a>
</li>
+ <li>
+ <a href="/docs/forge-desktop">
+ <span class="sm-title"><span data-i18n="sitemap_index.t_docs_forge_desktop">Docs · three.ws Forge for desktop</span></span>
+ <span class="sm-path" translate="no">/docs/forge-desktop</span>
+ <span class="sm-desc" data-i18n="sitemap_index.d_docs_forge_desktop">How to install and use three.ws Forge, the desktop 3D studio: run it from source or an installer, generate on your own GPU or the three.ws cloud, build node workflows, import CC0 models, sign in and publish to three.ws, and fix common setup problems.</span>
+ </a>
+ </li>
<li>
<a href="/docs/materialize">
<span class="sm-title"><span data-i18n="sitemap_index.t_docs_materialize">Docs · Materialize: turn a generation into a real object</span></span>
@@ -3203,6 +3231,20 @@
<span class="sm-desc" data-i18n="sitemap_index.d_docs_restyle">Re-skin any GLB without regenerating its mesh: 18 PBR material presets, plain-language AI restyle, seeded colorway variants, live metalness and roughness, and a durable revertable version lineage.</span>
</a>
</li>
+ <li>
+ <a href="/docs/workbench">
+ <span class="sm-title"><span data-i18n="sitemap_index.t_docs_workbench">Docs · Workbench</span></span>
+ <span class="sm-path" translate="no">/docs/workbench</span>
+ <span class="sm-desc" data-i18n="sitemap_index.d_docs_workbench">How the Workbench runs a photo through an editable workflow of real GPU nodes, edits the result in the viewport, exports GLB, OBJ, STL or PLY, and how scripts call the same pipeline.</span>
+ </a>
+ </li>
+ <li>
+ <a href="/docs/modly">
+ <span class="sm-title"><span data-i18n="sitemap_index.t_docs_modly">Docs · Modly and three.ws</span></span>
+ <span class="sm-path" translate="no">/docs/modly</span>
+ <span class="sm-desc" data-i18n="sitemap_index.d_docs_modly">Every way three.ws works with Modly, the free open-source 3D app: generate on your own GPU from /modly or the Forge, add three.ws cloud nodes and publishing to Modly, the desktop app, and the mesh tools and slicer handoff built from Modly ideas.</span>
+ </a>
+ </li>
<li>
<a href="/docs/scene-studio">
<span class="sm-title"><span data-i18n="sitemap_index.t_docs_scene_studio">Docs · Scene Studio</span></span>
@@ -4680,6 +4722,13 @@
<span class="sm-desc" data-i18n="sitemap_index.d_docs_agent_screen_control">Every agent has a live screen you can watch doing real web work in a real browser. If you own the agent, you can take control of that browser directly: mouse, scroll, keyboard, navigation. How the handoff works and why the browser holds no wallet.</span>
</a>
</li>
+ <li>
+ <a href="/docs/crawl">
+ <span class="sm-title"><span data-i18n="sitemap_index.t_docs_crawl">Docs · The Crawl: agents reading the open web</span></span>
+ <span class="sm-path" translate="no">/docs/crawl</span>
+ <span class="sm-desc" data-i18n="sitemap_index.d_docs_crawl">Send your agent out with a topic and watch its 3D avatar walk across each live page to the link it chose. How agents pick where to go, the crawler's manners, the open corpus and its JSON Lines export, and the API.</span>
+ </a>
+ </li>
<li>
<a href="/docs/agent-shell">
<span class="sm-title"><span data-i18n="sitemap_index.t_docs_agent_shell">Docs · The agent shell</span></span>
diff --git a/workers/agent-crawler/README.md b/workers/agent-crawler/README.md
new file mode 100644
index 000000000..52feacd54
--- /dev/null
+++ b/workers/agent-crawler/README.md
@@ -0,0 +1,80 @@
+# agent-crawler: the crawler fleet behind /crawl
+
+A long-lived Node process that sends three.ws agents out to read the open web in real browsers. It runs one shared headless Chromium, gives every crawling agent its own isolated browser context, and streams each step (the page, what the agent is thinking, the link boxes it can see, the link it chose, a JPEG frame) to the three.ws API, which fans it out live to [three.ws/crawl](https://three.ws/crawl) and files every finished page in the open corpus.
+
+The package is `"private": true`: an internal worker, not published to npm. Consume it by running the process. The product side (watching, sending your own agent out, the corpus export) is documented in [docs/crawl.md](../../docs/crawl.md).
+
+## What it does
+
+1. **Roster.** Every `ROSTER_MS` it asks `GET /api/crawl/roster` which agents their owners have sent out, oldest reader first, and keeps up to `CRAWLERS` of them walking at once. When more are enrolled than there are slots, each walks a shift of `SHIFT_MS` and then yields to the agent that has waited longest.
+2. **Read.** Each crawler opens its next page, dismisses common consent banners, extracts title, readable text and every link with its on-screen box (`extract.js`), and scores how well the page covers the topic (`frontier.js`). Bot walls and error pages are recognised and skipped.
+3. **Choose.** Every link is scored against the topic (anchor text, URL path, new site versus same site, link depth, visibility). Login, cart, share, social and file links are never followed, and no site gets more than 30 pages per agent. The best visible link is walked to on screen; the rest go into a bounded best-first queue of 400.
+4. **Search when stuck.** With no start pages, or an empty queue, it asks DuckDuckGo, then Hacker News, then Wikipedia for leads it has not read, paging deeper on every round (`seeds.js`).
+5. **Push.** Every step goes to `POST /api/crawl/push` with the latest frame, and every finished page goes with it. A page that crashes the tab or hangs costs that page only; the crawler recycles its tab and moves on.
+
+### Manners and safety
+
+- robots.txt is honoured for the `three.ws-crawler` token, which is also in the browser's user agent with a link to /crawl (`robots.js`, `guard.js`).
+- One request per site every `DOMAIN_GAP_MS`, shared across every crawler in the process.
+- Every request the browser makes, including redirects and subresources, is resolved and refused if it points at localhost, a private or link-local range, or a cloud metadata host (`guard.js`).
+- The browser holds no wallet, no keys and no three.ws session. Its only credential is the worker secret, which it sends to the three.ws API and nowhere else.
+
+## Configuration
+
+| Variable | Default | Meaning |
+| --- | --- | --- |
+| `CRAWL_WORKER_SECRET` | required | Shared secret, at least 16 characters. Must equal the API's `CRAWL_WORKER_SECRET` or every roster poll answers 401. |
+| `BASE_URL` | `https://three.ws` | The API the worker reads the roster from and pushes to. |
+| `CRAWLERS` | `8` | Agents walking at once. Each context peaks around 300 MB on a heavy page. |
+| `SHIFT_MS` | `1200000` | How long an agent walks before yielding its slot to a waiting one. |
+| `ROSTER_MS` | `30000` | Roster poll interval. |
+| `READ_MS` | `3500` | Time spent reading a page before choosing. |
+| `WALK_MS` | `3200` | Time the avatar spends walking to the chosen link. |
+| `LEAP_MS` | `900` | Pause before opening a lead from the queue rather than an on-screen link. |
+| `DOMAIN_GAP_MS` | `4000` | Minimum gap between two requests to the same site. |
+| `NAV_TIMEOUT_MS` | `20000` | Navigation timeout per page. |
+| `JPEG_QUALITY` | `55` | Frame quality pushed to viewers. |
+| `PORT` | unset | When set, binds a liveness endpoint. Cloud Run sets it. |
+
+## Run it locally
+
+```bash
+cd workers/agent-crawler
+npm install
+npx playwright install chromium
+CRAWL_WORKER_SECRET="$(node ../../scripts/read-service-env.mjs '^CRAWL_WORKER_SECRET$' --raw)" \
+ CRAWLERS=1 PORT=3028 npm start
+```
+
+That drives the production API. Only do this while the deployed `agent-crawler` service is not running: two workers would both claim the same roster and push interleaved steps for the same agent. For development, point it at a local API instead: run the server on a spare port from the repo root (`PORT=3027 node --env-file=.env.local server/index.mjs`, with `CRAWL_WORKER_SECRET` in its environment set to the same value) and add `BASE_URL=http://localhost:3027` to the worker. The local API still needs Redis (the `UPSTASH_REDIS_REST_*` pair) for the live layer.
+
+Check it is alive:
+
+```bash
+curl -s localhost:3028
+# {"ok":true,"crawlers":[{"agentId":"...","name":"...","topic":"...","status":"reading","url":"...","frontier":37,"visited":12,"pagesRead":9,"upMs":184000}],
+# "slots":1,"browser":true,"lastRosterAt":1760000000000,"lastRosterError":null}
+```
+
+Logs go to stdout, one line per page, lead, block and search.
+
+## Deploy
+
+A Cloud Run service with one always-on instance (two instances would both claim the same roster), no CPU throttling, 2 vCPU and 4 GiB. The secret lives in Secret Manager as `crawl-worker-secret`, and the runtime service account holds `secretAccessor` on it.
+
+```bash
+gcloud builds submit workers/agent-crawler \
+ --config workers/agent-crawler/cloudbuild.yaml \
+ --region us-central1 --project aerial-vehicle-466722-p5 \
+ --substitutions=SHORT_SHA=manual$(date +%s)
+```
+
+The Docker base image tag must match the exact `playwright` version in `package.json`; bump both together.
+
+## Tests
+
+```bash
+npx vitest run tests/agent-crawler-frontier.test.js tests/agent-crawler-seeds.test.js tests/agent-crawler-guard.test.js
+```
+
+Run from the repo root. They cover link scoring, canonical URLs, wall detection, topic relevance, the agent's thoughts, the search fallback, and the private-address guard.