This week, IBM tried something different. Instead of slides about agents, we built one, live, on stream. We opened an empty editor, typed a single sentence, and watched it become a three dimensional, interactive, fully embeddable AI agent. The session, "Building 3D AI Agents Live: From Prompt to Embeddable Agent in Minutes," ran on June 24 and streamed on IBM Cloud, with the three.ws core engineering team driving and a special guest from IBM joining the build.

In about thirty minutes we went from nothing to a rigged, talking 3D agent, embedded it into a web page as easily as you would drop in a video, and then wired it to real tools and live data so it could take action rather than only answer. Every demo ran against production systems, and the on-chain payments settled real money in real time.

To everyone who joined us live, thank you. The questions were sharp, the chat was busy, and you pushed the team to show the parts that usually stay behind the curtain: the deployment pipeline, the trust layer, and the economics underneath an agent that can pay for its own work. And to the three.ws team, thank you for building in the open, and for giving our teams and community an honest look at where agent interfaces are heading. Live building is hard. Live building a 3D agent and embedding it with a single line of HyperText Markup Language, and then handing it a wallet and a set of tools is much harder. You made it look effortless, which was exactly the point.

This post is part recap and part status update, because a great deal has shipped from the three.ws team and the audience asked for the full picture. It runs long on purpose. There is a lot to cover.

• Watch the replay: three.ws | Building 3D AI Agents Live
• Try the live demos: three.ws

The interface after the chat box

Most enterprise AI agents today live inside a text box. That is a perfectly good interface for a great deal of work. But for a growing class of experiences, including brand agents, product guides, tutors, training characters, in-world companions, and storefront assistants, a text box leaves most of the value on the table. A text box cannot be present. It cannot stand in a room, point at a product, walk a customer through a space, or carry a persistent identity that follows a user across a site and acts on their behalf.

The thesis three.ws brought to the session is simple, and we think it is correct. The next interface for AI is spatial, embeddable, and able to act. three.ws frames its own mission as giving AI a body, and the platform is the receipt: a browser-native 3D AI agent that renders rather than merely replies. The agents are even aware of the page around them. Drop one in, and it can hop across the cards of a layout, react to the document it lives in, and politely cover its eyes when you type a password into a form. That last touch runs on the Privy sign-in integration, and it captures the whole idea. The agent is a participant on the page, not a widget bolted onto it.

What makes this practical for enterprises now is that three.ws has solved the problems that usually kill these projects. Deployment friction, meaning how you ship a 3D agent without a games team and a custom pipeline. The ability to transact, meaning how an agent pays, autonomously and auditably, for the data and tools that make it useful.

1. Generate from a prompt. A sentence becomes a textured, rig-ready 3D model in minutes. three.ws runs a NVIDIA Inference Microservices (NVIDIA NIM), using the Microsoft TRELLIS model, with no account and no application programming interface key required, alongside higher fidelity paid tiers. It then automatically rigs the result so arms, legs, and face are animation ready, never a frozen pose.
2. Render in the browser. The model loads in the browser using WebGL 2.0, validated against the Khronos Group GL Transmission Format (glTF) 2.0 specification, with Draco, KTX2, and Meshopt decompression. There is no server-side processing.
3. Give it a brain. The agent gets a large language model brain with memory and emotion. Builders pick the model, with the latest Claude models from Anthropic and a multi-provider router available, and IBM Granite on IBM watsonx.ai selectable as a first-class option.
4. Register an identity. Optionally, the agent is registered on-chain for a stable identity, a wallet, a signed action history, and a reputation that cannot be forged.
5. Embed it anywhere. The finished agent ships as a Web Component, written simply as an agent-3d HyperText Markup Language tag, so adding a persistent, interactive 3D agent to any website or app is one line. As easy as embedding a video, exactly as billed.

Underneath the reasoning and safety of those agents sits IBM Granite, served through IBM watsonx.ai. 

Built on IBM Granite and IBM watsonx.ai

This is the part closest to home for this community. three.ws is an IBM Business Partner, and IBM Granite is a first-class brain inside its agent runtime. Every inference is a real call to IBM watsonx.ai, scoped to your own IBM Cloud project. There is no mock path anywhere in the integration. When credentials are not present, an endpoint returns a clear "not configured" state rather than inventing a result. The team maps each task to the right Granite model.

That integration is not a single hook. It is a full suite of Granite-powered surfaces that three.ws built to show what these models can do once an agent has a body and a wallet. There are seven of them, and each one runs against production systems with nothing staged.

• Reasoning and narration. The granite-3-8b-instruct model gives an avatar its voice and personality, streamed through the standard agent runtime so a Granite-brained agent speaks, emotes, and uses skills like any other.
• Semantic discovery, the Agent Galaxy. The granite-embedding-278m-multilingual model embeds every public agent and projects the vectors into a navigable 3D star-map where similar agents cluster together. A natural-language search, for example "a witty Solana trading assistant," flies the camera to the nearest match by meaning rather than by keyword.
• The Identity Firewall. Those same embeddings, paired with Guardian, block impersonation before a new agent is ever created. A candidate name and description are compared against every existing agent, and a too-similar identity is refused. This matters, because every agent on the platform holds a wallet and earns real reputation, which makes it an economic target.
• Governance, the Trust Layer. The granite-guardian-3-8b model sits between an agent's reasoning and its actions as a real veto, not a user-interface flourish. Before an autonomous agent sends value, Guardian classifies the proposed action across named risks, including jailbreak, harm, and bias, and collapses them to a single decision: allow, review, or block. A block verdict vetoes the action. Every verdict is written into a tamper-evident, hash-chained audit ledger that the browser can re-verify with SHA-256.
• Forecasting, the Oracle and the Digital Twin. The Granite TimeSeries models, the TinyTimeMixer family, forecast a live market series and render it as a 3D confidence cone narrated aloud by an avatar. The Digital Twin goes further, back-testing its own past predictions and reporting accuracy, then running what-if simulations on counterfactual but real data.
• Vision. The granite-vision-3-2-2b model reads a rendered avatar, or any image, and returns a complete agent identity, including appearance, persona, a suggested name, a one-line bio, tone tags, and a fitting voice. It turns a face into an agent.
• Granite Proof. A governed Granite forecast can be hashed and notarized on-chain, so an AI claim becomes something anyone can verify on a public ledger. If Guardian vetoes the narration, the agent refuses to sign, so there is no proof for a claim that did not pass governance.

For developers who want Granite inside their own tools, three.ws also publishes an open-source connector, the @three-ws/ibm-watsonx-mcp package, which exposes IBM watsonx.ai to any Model Context Protocol host, including Claude Desktop, Claude Code, and Cursor, using your own IBM Cloud credentials and talking directly to the watsonx.ai representational state transfer (REST) application programming interface for chat, generation, embeddings, tokenization, and model listing. A companion, @three-ws/ibm-x402-mcp, plus a hosted IBM x402 server, offer pay-per-use Granite to agents that do not have an IBM account, settling per call.

The combination is the point. IBM Granite on watsonx.ai brings the trusted, enterprise-grade model layer. three.ws brings the spatial interface and the on-chain micropayment rail. Put them together, and an embeddable 3D agent can reason with a governed enterprise model and pay, per call, for exactly the data and tools it consumes. That is a clean, auditable, pay-for-what-you-use architecture, and it fits how enterprises actually want to adopt agentic AI.

three.ws Forge: from a prompt, a photo, or a sketch to a model

The headline of the live build was speed. Text in, 3D agent out. That is Forge, the three.ws generation pipeline that turns a text prompt, one to four reference photos, or a hand-drawn sketch into a textured, rig-ready GL Transmission Format Binary (GLB) model. There is a free draft tier that needs no account, plus standard and high-fidelity tiers with physically based rendering (PBR) materials. Quality runs in three tiers, roughly a twelve-thousand-polygon draft, a thirty-thousand-polygon standard, and a two-hundred-thousand-polygon high tier with physically based textures. Generation routes across multiple engines, including a free, platform-keyed lane powered by NVIDIA Inference Microservices running Microsoft TRELLIS for both text-to-3D and image-to-3D, plus a bring-your-own-key path to native geometry engines such as Meshy and Tripo for the cleanest quad topology, where your key never leaves the browser.

What we appreciated as engineers is that Forge never becomes a dead end. A generated model flows straight into the rest of the platform.

• Scene Studio, a full 3D scene editor, lets you import models, compose scenes, edit materials and lights, and export.
• Auto-rig and retarget turns a static mesh into an animatable character, using a rig-agnostic system described in the next section.
• Restyle and retexture re-skins a model as voxel, brick, voronoi, or low-poly, or retextures it from a fresh prompt.
• Pose Studio is an articulated mannequin with forward and inverse kinematics on hands and feet and a keyframe timeline, so you can author a pose or a reusable clip and export it.
• Voice Lab and Mocap Studio let you audition and bind voices, and capture and retarget motion into reusable animation clips.
• Selfie reconstruction turns a few photos into a rigged avatar of you.

The same engine is one free, authentication-free HyperText Transfer Protocol call, exposed to any AI assistant through a 3D Studio Model Context Protocol server with fifteen tools, including text-to-3D, image-to-3D, auto-rig, apply-animation, stylize, and retexture. A human in a browser and an autonomous agent reach the exact same capability. The public Prompt-to-3D engine and Scene Studio shipped in June, and the team has not slowed down since.

The avatar and animation engine: a universal rig

Forge produces the body. The avatar engine brings it to life. A generated or uploaded model is rigged and driven by a pre-baked library of more than one hundred motion clips, including idle, walk, gestures, and a seventy-animation emote set, with support for uploading your own Filmbox (FBX) and Biovision Hierarchy (BVH) motion.

The detail worth highlighting is the universal rig. Rather than supporting a curated allowlist of skeletons, three.ws canonicalizes bone names across the major conventions, including Mixamo, Avaturn, Unreal, the Virtual Reality Modeling format and VRoid, Daz and Genesis, MakeHuman, and Blender, and retargets motion onto whatever humanoid you bring, legs included. The practical result is that almost any avatar walks, gestures, and emotes correctly instead of collapsing into a static pose.

On top of that sit real-time audio-to-face lip-sync, where speech audio is analyzed and drives the fifty-two standard facial blendshapes so the mouth and expression move together, free neural text-to-speech with no key, a free speech-to-text lane, voice cloning, real-time voice conversation where the agent listens, reasons with memory and tools, then answers in voice, and a live identity nameplate anchored to each avatar showing its name, vanity-highlighted wallet address, and a wealth tier that lights up as the agent gets funded. Augmented and virtual reality support is in active development.

The agent runtime: a brain, memory, emotion, a voice, and awareness of the page

A body is only half of it. three.ws wraps any avatar in a real agent runtime.

• A brain with a tool loop. The default brain runs the latest Claude models with a structured tool loop, up to eight tool iterations per turn, and built-in actions such as wave, look-at, play-clip, set-expression, speak, and remember. A multi-provider brain router can fan one prompt out to several models at once for side-by-side comparison, and IBM Granite is a first-class selectable brain.
• An empathy layer. Emotion is not a finite-state machine. It is a continuous weighted blend across celebration, concern, curiosity, empathy, and patience, driven by real events and rendered live through morph targets on the face. In the chat surface you can even watch the agent's thoughts stream in real time as it reasons.
• A voice with real lip-sync. Web Speech is built in, and production voice cloning adds a custom voice from a few seconds of audio. The team has previewed real-time voice conversation, augmented and virtual reality, and an autonomous voice agent that can join a live audio space, request to speak, listen, and respond.
• Awareness of the page it lives on. A three.ws avatar is aware of the Document Object Model around it. It can hop across the cards of a real web page, react to events, and politely cover its eyes when you type into a password field, courtesy of the embedded-wallet integration with Privy. This is embodiment that reacts to the document, not just to the prompt.
• Composable skills. Skills install from InterPlanetary File System, Arweave, or HyperText Transfer Protocol, each a self-contained bundle of tool definitions and handlers, with trust modes that range from open, to owned-only, to an explicit allowlist.
• Persistent memory. An embeddings-backed memory with an entity graph survives reloads, and can optionally be seeded from a user's own X, GitHub, or Farcaster history with explicit consent.

The agent's mind: memory you can own

An agent is only as good as what it remembers, and three.ws does something unusual with that idea. A Brain Studio lets you build an agent's personality as a visual circuit and hear the change land instantly. A Memory Studio and a 3D Mind Palace render an agent's memories as a constellation you can orbit and walk through, where size and proximity encode importance. You can pin a memory or flick one away to forget it. Reflection and Dreams consolidate memories into reviewable insights while you are away.

An emotional-state system derives a genuine mood, a map of valence and arousal, from the agent's conversations and outcomes, which then reads out in its expression and posture and decays toward a baseline over time.

Most importantly, the memory is portable and provable. Each memory can be signed by the agent's wallet and re-verified offline. You choose where it lives, whether local, public InterPlanetary File System, or encrypted to your own key, then export a signed brain file and re-import it elsewhere, where forged bundles are rejected. A memory-grounded autopilot then lets a scoped agent propose actions drawn from its highest-importance memories, with a receipt linking each action back to the memory that motivated it, always within a spend cap and an append-only signed log. Every decision an agent makes can be written to a Reasoning Ledger, an auditable, on-chain-verifiable track record. A portable, exportable, verifiable brain means an agent's mind is genuinely owned, not locked in.

Embed an agent like a video: the distribution layer

The piece that makes all of this shippable is the agent-3d Web Component, a zero-framework custom element. Drop one tag into any page, document, post, or app, and you have a persistent, interactive 3D agent. A what-you-see-is-what-you-get embed editor turns it into one line of HyperText Markup Language in about thirty seconds. Around it sits a whole distribution toolkit.

• Five widget types, including a talking agent with voice in and out, a turntable product-style display, an animation gallery, an ERC-8004 passport card that shows the agent's on-chain identity, and a hotspot tour for guiding visitors through a scene.
• A clean programming interface, with methods such as say, ask, play, wave, look-at, and express-emotion, and lifecycle events such as agent-ready, brain-message, skill-tool-called, and voice-transcript. It runs inline, floating, or headless.
• A React component library for application teams, plus a drop-in page-agent that narrates any page and lets visitors choose their own avatar, and a lightweight corner walk-companion that strolls a site.
• Open Graph and oEmbed metadata built in, so a shared link unfurls as a rich 3D preview, with versioned content-delivery bundles for stable embeds.
• Action bridges, so an embedded agent can drive the host page rather than just sit on it.

The proof is in where it already runs. three.ws has shipped live, interactive 3D agents into production surfaces, including the SperaxOS decentralized finance stack, where the avatar nods on a swap, lights up on a yield event, and shows concern with its body language as a position approaches liquidation, and a Shopify storefront. Paste a link, and a real, live agent renders in the conversation, not a video. Embedding an intelligent agent really is as simple as embedding a video.

Worlds, studios, and real-world presence

three.ws treats 3D as a place, not just a viewer. Agents and people share multiplayer worlds. Coin Communities, also called Cosmos, render living, walkable 3D worlds for each Solana token, wired to real market data, with spatial voice chat, real-time multiplayer sync, holder-gated areas, a cosmetics economy with a cross-world wardrobe, and quests, loot, and mounts. Drop-in mini-games keep the worlds lively, including faction battles, King of the Totem, and Tag, alongside a collaborative Build mode where you place, rotate, snap, and persist props that appear instantly for everyone and remain after you leave. All of it is server-authoritative, so outcomes cannot be faked from outside.

Walk lets you roam any avatar across a full-page playground, with a hub, a leaderboard, creator analytics, and click-to-walk that picks up where you left off. For creators there is a full set of browser studios, including Scene Studio for composing and exporting scenes, Pose Studio with full inverse kinematics, Voice Lab for auditioning and binding voices, and Mocap Studio for capturing and retargeting motion.

And with the in-real-life feature, your avatar steps off the screen entirely. You can place an agent on your real floor with augmented-reality anchoring, where it hides behind real-world objects, breathes and idles, pins to a real spot others nearby can see, pairs with smart glasses, and supports multiplayer augmented reality, all behind clear location-privacy controls. three.ws even bought a Solana Seeker device to test its 3D agents and on-chain identity on hardware, and is building a dedicated application with exclusive experiences for Solana Mobile owners.

A full Model Context Protocol ecosystem: thirty-eight servers

The reason the on-stage agent could do things is the Model Context Protocol, the open JavaScript Object Notation remote-procedure-call standard for connecting AI systems to tool servers. three.ws has gone unusually deep here. It now operates thirty-eight Model Context Protocol servers. Six are hosted remote servers that run over Streamable HyperText Transfer Protocol with nothing to install, added by web address, and thirty-two are install-and-run servers published to the Node Package Manager registry under the @three-ws scope, each runnable in one line. All of them are discoverable in Anthropic's official Model Context Protocol registry, the canonical directory used inside Claude and other clients, under the io.github.nirholas namespace, so any compatible assistant can find them by name. Authentication is handled properly, with OAuth 2.1, dynamic client registration, and Proof Key for Code Exchange for end users, or application keys for server-to-server.

The hosted six sketch the surface area.

• three.ws, for avatars, glTF and GLB validation, agent data, and memory.
• 3D Studio, for paid text-to-3D and image-to-3D, rigging, retexture, and optimization.
• Agent Wallet, the agent's own wallet, with balance, find-and-pay services, and endpoint monetization.
• x402 Bazaar, to discover and price paid agent services across the network, built with help from Coinbase.
• pump.fun, free, read-only Solana token tools.
• IBM x402, pay-per-use IBM Granite.

That last one is a genuine first. three.ws shipped what it believes is the world's first x402-enabled Model Context Protocol server on IBM Cloud. The @three-ws/ibm-x402-mcp server turns IBM Granite into a metered utility any AI agent can call. The operator holds the IBM credentials and funds the inference, and the caller pays a few cents in United States Dollar Coin (USDC) per call, with no IBM Cloud account, no subscription, and no key signup. Five tools, covering chat, code, embeddings, document analysis, and time-series forecasting, ship over both standard input and output for desktop clients and Streamable HyperText Transfer Protocol for hosted clients. An unpaid call returns an HyperText Transfer Protocol 402 quoting the exact price, the client pays and retries automatically, and settlement only happens on-chain after the tool succeeds.

The rest of the fleet covers creation, including text-to-3D, avatars, scenes, voice and face, and vision, payments and wallets, including a self-custodial buyer, the Bazaar, $THREE tools, and a bridge that can pay any x402 endpoint on the open web, an autonomous control plane with scopes, daily spend caps, and propose, execute, and undo, market intelligence, naming and identity resolution, a multi-provider language-model router with automatic fallback, portfolio and provenance, notifications and billing, and the Agora agent economy. The first three.ws server landed in Anthropic's registry in late April, the catalog has grown steadily ever since, and the team also pursued an official Claude Marketplace submission so Claude users can reach the toolkit directly.

A representative slice, each installable in one line:

npx -y @three-ws/scene-mcp        # speak a 3D scene into being
npx -y @three-ws/x402-mcp         # find, inspect, and pay any x402 service
npx -y @three-ws/ibm-watsonx-mcp  # IBM watsonx.ai on your own account
npx -y @three-ws/ibm-x402-mcp     # pay-per-use IBM Granite
npx -y @three-ws/autopilot-mcp    # scopes, spend caps, propose, execute, undo
npx -y @three-ws/agora-mcp        # join the agent economy and earn $THREE

Documentation lives at three.ws/docs/mcp.

x402: payments built for agents

If the Model Context Protocol is how an agent reaches a tool, x402 is how it pays for one, and it drew the most questions during the live build. x402 is an open micropayment standard built on the long-dormant HyperText Transfer Protocol 402 Payment Required status code. An agent calls a paid endpoint, receives a 402 with a signed payment challenge, signs a gasless authorization from its own wallet, settles on-chain, and the original request completes with a verifiable receipt, all in one round-trip, with no account and no card.

three.ws built its platform on x402 and made the implementation genuinely multi-chain and real.

• Settlement in USDC or in $THREE across Solana, through the Coinbase Developer Platform facilitator with Permit2 gasless authorizations, with support for BNB Chain x402. A single 402 challenge can advertise both assets at once.
• An x402 Bazaar, where services are discoverable and searchable by tag, price, and chain, and bought through a clean checkout, listed in public directories including x402scan. A single paid endpoint has handled the classic example since April: send a tenth of a cent in United States Dollar Coin, and receive a 3D avatar with a verifiable on-chain identity it can render.
• A merchant software development kit, @three-ws/x402-server, that turns any endpoint into a paid one and advertises both assets in a single 402 challenge, with subscriptions, idempotency tokens, receipts, and paid asset downloads. There is also an x402 Console to run a paid-application business end to end, and a provider hub with real uptime telemetry.
• Pay-by-name, addressing a payment to a username, a Solana Name Service .sol name, or a *.threews.sol subdomain instead of a raw wallet string. Every named agent's 402 manifest shows the human-readable name next to the wallet, so a payer verifies who they are paying before signing.
• Deterministic cross-chain contracts, where three.ws deploys through a CREATE2 factory at a vanity eight-zero-prefix address, so its x402 payments contract lives at matching addresses across every supported chain.
• Single-use replay protection, so a captured payment can never be re-spent, plus authorize-once flows that let an agent pay with no repeated wallet pop-ups, and reach into developer tools such as Visual Studio Code.

 We paid a tenth of a cent in United States Dollar Coin from our own wallet, using MetaMask on Base or Phantom on Solana, to call a real three.ws data application, and watched the 402 challenge, the signature, and the on-chain settlement receipt appear live. You can run the exact same flow at three.ws/ibm/x402-demo. There is also a live $THREE market-intelligence oracle you can pay one cent to call for price, liquidity, volume, and a signal, the same oracle an in-world kiosk buys from, fed by live market data.

There is a self-sustaining-economy angle to this as well. three.ws reverse-engineered the pump.fun agent-payments software development kit, reconstructing it into editable source, so an agent can launch and trade its own token, charge for its skills, collect fees, and run automated buybacks and burns from its own revenue. The 3D avatar subscribes to its own on-chain events over a live connection, so a payment lands and it celebrates, a buyback fires and it reacts live, and a withdrawal is logged to its identity timeline. The avatar responds to its own economics in real time.

Documentation lives at three.ws/docs/x402.

Identity, reputation, and verifiable trust on-chain

The deeper bet three.ws is making is that agents need portable identity and provable reputation, the same way enterprises need auditability. So every agent carries on-chain identity, without putting a database in the trust path.

• Metaplex Core where the asset's public key is the agent identifier.
• ERC-8004 portable identity and reputation on any Ethereum Virtual Machine chain, with an Identity Registry, a Reputation Registry, and a Validation Registry, where each agent is a token with a stable identifier, an owner wallet, and a delegated signer.
• Skill licenses minted as one-of-one Solana Program Library non-fungible tokens plus an on-chain program-derived address, a trustless alternative to a database access check.
• Composable agent-to-agent authorization through delegated permissions, so a signer can act on an owner's behalf without ever exposing the root key.
• An append-only, signed provenance log of agent actions, plus custody integrity, where the platform commits a Merkle root over agent-wallet state to Solana, and anyone can recompute the leaf and verify the proof in the browser.
• Names everywhere, including the Ethereum Name Service on Ethereum Virtual Machine chains, the Solana Name Service for .sol, and one-transaction *.threews.sol subdomain minting where three.ws absorbs the gas, plus client-side vanity-address generation so an agent can pick its prefix.

The first three hundred and thirty-three 3D avatars created on three.ws were inscribed on-chain permanently, each a real agent with its own wallet, reputation, and x402 payments, registered in the Metaplex Agent Registry and available on Magic Eden. For agents that prove identity on both Ethereum and Solana, a cross-chain handshake resolves two chains to one reputation, re-derived in your browser.

The quiet win here is onboarding. Most of those early avatars were made by people who had never touched a seed phrase, a wallet, or a block explorer. You make a 3D avatar, and three.ws turns it into a real on-chain agent, wallet and all, with the cryptography handled quietly in the background. The throughline with the Granite Trust Layer is deliberate. Guardian decides whether an agent may act. The on-chain record proves what it did. Governance and provenance, working as a pair.

An actual agent economy: Agora, the Commons

A working economy for agents, and now humans, where citizens register, claim work, do it, get paid, and verify one another.

Agora is a watchable 3D commons and job board. Citizens, agents and people alike, post bounties that escrow $THREE on-chain, then claim and complete real work. A Sculptor produces a 3D model with Forge, a Scribe researches and writes, a Cartographer composes scenes, an Appraiser reads market sentiment, and a Namekeeper resolves .sol and Ethereum Name Service names. A Verifier closes the loop. It re-downloads each deliverable, recomputes its SHA-256 fingerprint, and leaves an on-chain attestation, a vouch when it matches and a flag when it does not. Every job ends in a real artifact and a proof. Every citizen carries a living passport with a derived trust grade and slashable stake. The whole economy is open over the Model Context Protocol through @three-ws/agora-mcp, so any outside assistant can join the workforce and earn.

Around Agora sit the other pieces of a working agent economy. An AgenC task marketplace and registry gives agents discovery, status, and reputation for agent-to-agent coordination. A bounty board with an AI judge, agent-to-agent delegation and autonomous agent-to-agent trading, and the verifiable supply chain, where a generated model's SHA-256 fingerprint is written on-chain so anyone can re-download, re-hash in their own browser, and confirm the match end to end. There are Money Streams to pay an agent by the second, Patronage tips that build a real relationship, Strategy Objects you can own and fork and equip on an agent, and revenue splits that pay collaborators exactly and automatically. World Lines let you walk up to an agent in person and earn a cryptographically real proof that you were there.

A wallet that defends itself

Because three.ws agents hold and spend real value, the team built the wallet to be defensible, not just functional.

• A plain-English policy engine. Write a rule such as "trade up to fifty dollars a day on tokens at least a day old, never spend the last one Solana, stop on a thirty percent drop," and it compiles to deterministic guardrails you can back-test against real history. The autopilot spends Solana rather than your $THREE by design.
• Real-time self-defense. The wallet learns each agent's normal spending shape and scores every outbound action instantly, freezing anomalies such as a sudden burst of spends or a first-time large payee for one-tap approval or a safe-address sweep.
• Proof-of-Custody. Hourly snapshots of wallet balance and history are committed to Solana through a Merkle root, so anyone can verify in their own browser that platform custody reconciles. It is a public integrity surface, not a trust-us claim.
• Recovery and continuity. One-tap freeze, a full custody audit trail, and social recovery and inheritance so a funded agent never dies with its owner.
• Vanity wallets, ground client-side or by a WebAssembly grinder, with a trustless proof that the key was never kept, a bounty market where a fleet grinds a chosen address, and a rarity gallery.

There is even a copy-trading primitive, where an agent with a proven on-chain record can take staked United States Dollar Coin, issue net-asset-value-priced shares, share realized profit pro-rata, and enforce per-trade caps and a drawdown circuit breaker, all with an on-chain audit trail. Copy-trading is non-custodial and mirrors proven agents on your own terms, and a conversational copilot lets you talk to your agent and have it trade within the limits you set.

Market intelligence, baked in

For the trading and discovery side of the agent economy, three.ws ships a deep intelligence layer, all wrapped in guardrails and verifiable track records. There is an Oracle that produces one conviction score per launch, fused from multiple signals, with per-signal win rates that explain every decision, plus a live trade tape and a 3D conviction graph. There are radars and leaderboards, including Coin Radar, Smart Money Radar that follows wallets with a real track record, and a Trader Leaderboard ranked by a record you can verify on-chain, with self-dealing excluded so reputation cannot be faked.

Execution comes with guardrails, including programmable orders covering limit, stop, trailing, dollar-cost averaging, time-weighted average price, and conditional triggers, a real-time terminal, and back-testing against real history before a single lamport is risked. Coin pages embed live swaps through Jupiter, every agent-launched coin appears in a launches feed, and a Pump Visualizer lets a coin's 3D look track its market value in real time. Each capability is available as both an application interface and a Model Context Protocol server, so an autonomous agent can act on the same data a human sees. For an enterprise reader, the pattern underneath all of this is the relevant part: autonomous, policy-bounded, fully auditable agent commerce, and the same primitives apply to any agent that must transact and prove what it did.

Voice

Agents speak and listen. There is free neural text-to-speech with no key, a free speech-to-text lane, voice cloning from a few seconds of audio, real-time audio-to-face lip-sync so a face moves with its voice, a mocap studio, and an autonomous voice agent that can request speaker access in a live audio space, listen in real time, and respond.

The developer platform

Everything above is meant to be built on, not just used.

• Eighteen @three-ws software development kit packages are live on the Node Package Manager registry, pure ECMAScript modules with no build step, hand-written types, and two hundred and sixteen tests passing across the suite. They cover Forge for text-and-image to 3D, Voice for speech recognition, text-to-speech, and lip-sync, Names for Ethereum Name Service and Solana Name Service resolution and pay-by-name, Intel, Reputation for ERC-8004, the x402 merchant server, Agent Memory, Guardian for content safety on Granite Guardian, Skill License, Mocap, Strategies, Agent Guards, Vanity, and more. Each one wraps a live, running endpoint. Install one, for example npm i @three-ws/forge, and you are generating 3D from a prompt.
• A full representational state transfer application interface with an OpenAPI 3.1 specification.
• A complete OAuth 2.1 authorization server, with Proof Key for Code Exchange, dynamic client registration, revocation, introspection, and discovery, plus scoped developer keys, so external systems connect securely.
• A drop-in pay-per-call fetch wrapper, a Walk companion, and a page-agent that can narrate any page.
• One open-source monorepo, under the Apache 2.0 license. The viewer, the agent runtime, the contracts, the backend, and the Web Component are all in the open, and the chat surface itself is fully open-source and forkable. There is also a public status page with live uptime monitoring. The whole platform is browser-native, built on three.js, works keyboard-only at Web Content Accessibility Guidelines level AA, and is localized into multiple languages.

$THREE: the network's native token

The platform's native settlement asset is $THREE, native to Solana at contract address FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump. It is the asset that escrows work in Agora and settles agent payments alongside United States Dollar Coin. Everywhere else, payments are coin-agnostic and supplied at runtime by the user. Over the past two months it has built broad availability and verification across the ecosystem.

• Price listed on Coinbase and supported in Coinbase Wallet.
• Listed on CoinGecko and across the CoinMarketCap community.
• Verified on Jupiter's verified list.
• Listed on Bybit Alpha and discoverable through BNB Chain's DappBay.

For enterprises, the relevant point is not speculation. It is that the same token rail an agent uses to pay for a Forge render or a Granite inference is liquid, verified, and discoverable through standard venues, always against the contract address above.

Standards and the open web

This is the part that should interest an enterprise audience most. three.ws is not only building a product. It is helping write the rules for agents on the open web. The team holds World Wide Web Consortium membership, has contributed to the Agent Identity Registry Protocol Community Group, and has proposed a new Community Group focused on 3D AI agents and on-chain identity, so that embodiment and agent-to-agent payment can become web standards rather than one vendor's interface. Combined with its work on open rails, including the open Model Context Protocol, the open x402 payment scheme, ERC-8004 on-chain identity, and the Khronos Group glTF format for 3D, the pattern is consistent: open standards over walled gardens. That is a posture worth supporting.

The pace of shipping: launch to a live build with IBM in two months

What makes the breadth above remarkable is the pace. three.ws went from first public appearance to a live build with IBM in roughly two months.

• Late April 2026, public launch. Browser-native 3D agents with large-language-model brains, memory, emotion, native Solana wallets, on-chain identity, and a one-line agent-3d embed. Listed on Anthropic's Model Context Protocol registry and live as a paid x402 endpoint on x402scan within days. Published to the Node Package Manager registry.
• Early May, partnerships and listings stack up. The Alibaba Cloud International Marketplace, a Google Cloud for Web3 Startups engagement, and the agent-payments stack with automated buyback and burn. $THREE reaches broad availability and verification.
• Mid May, distribution and reach. The embed editor ships, putting a 3D agent on any site in about thirty seconds, alongside real-time voice and augmented and virtual reality previews, a HackerNoon builder initiative, and native deployment on BNB Chain with live mainnet contracts and a DappBay listing.
• Late May, awareness and trust. Document-Object-Model-aware agents that hop across page elements and cover their eyes at a password field, an Amazon Web Services Partner Network membership with a marketplace listing and an engineering write-up on the AWS Builder Center blog, and a Product Hunt launch.
• June, depth and the IBM collaboration. The public Prompt-to-3D engine and Scene Studio, the x402 Bazaar Model Context Protocol server built with Coinbase, the first three hundred and thirty-three avatars minted on-chain through Metaplex and listed on Magic Eden, and the IBM collaboration moving into the open, culminating in this live build streamed on IBM Cloud.

Shipped just this past week

To convey the velocity up close, here is a sample of what landed in the days around the session.

• Live identity nameplates. Every avatar now wears a nameplate anchored to its 3D body, showing its name, a vanity-highlighted wallet, and a wealth-tier glyph that lights up as the agent gets funded.
• Agora over the Model Context Protocol. Agents can now join the workforce and earn $THREE through the open tool standard.
• Replay protection on paid Model Context Protocol calls. A single-use lock on each signed payment, so a captured payment can never re-run a paid tool for free.
• Hardened launches and generation. Stronger on-chain confirmation for coin launches, and a generation pipeline that pins model fetches to the provider's own delivery hosts, a defense against server-side request forgery.
• A focused security and polish pass. Coverage across the newest surfaces, including escrow recovery and presence-gated location privacy, plus a platform-wide dead-link sweep so every navigation, footer, and pretty web address lands somewhere live.

This is a team that treats security and polish as features, not afterthoughts, which is exactly the standard you want from a partner building agents that hold wallets.

Partnerships and where to find three.ws

three.ws has built across all of the major clouds and a wide set of ecosystem partners.

Cloud and enterprise

• IBM and IBM Cloud. An IBM Strategic Partner, with the agent runtime running on IBM Granite through watsonx.ai, exposed over the Model Context Protocol and x402, with Granite Guardian for safety, and this live community build streamed on IBM Cloud.
• Amazon Web Services. An Amazon Web Services Technology Partner in the Partner Network, live on the marketplace for streamlined enterprise procurement, with a published engineering contribution on the AWS Builder Center blog describing how the team metered a software product through the marketplace and bridged entitlements to an on-chain x402 paywall.
• Google Cloud. A Google Cloud for Web3 Startups engagement that expands rendering and compute capacity.

AI and developer ecosystem

• Anthropic. Early presence on the official Model Context Protocol registry, with thirty-eight servers, and an official Claude Marketplace submission, so the full toolkit is usable from Claude and other clients.
• Coinbase. $THREE listed on Coinbase and supported in Coinbase Wallet, plus the Coinbase Developer Platform powering x402 settlement on Base and service discovery in the Bazaar.
• NVIDIA and Microsoft. The free, production text-to-3D and image-to-3D lane behind Forge, NVIDIA Inference Microservices running Microsoft TRELLIS.
• Privy. Embedded wallet sign-in for friction-free onboarding, including the agent that covers its eyes when you type a password.

Chains, wallets, and on-chain venues

• Solana, Solana Mobile, and Colosseum. Native on-chain identity and payments, an official entrant in the Solana Frontier Hackathon run by Colosseum, the Mobile Wallet Adapter wired into the application, and a dedicated Seeker experience in progress.
• BNB Chain. Verified and listed on DappBay, with live mainnet contracts and native x402 settlement, no bridge and no wrapped assets.
• Metaplex and Magic Eden. The Agent Registry and a marketplace home for the first wave of on-chain avatars.
• Jupiter. The $THREE token is verified on Jupiter, and Jupiter swaps are embedded directly into coin pages.
• Sperax. 3D agents shipped end to end into the SperaxOS decentralized finance stack.
• zauth. A cybersecurity partner securing the growing agent surface, with its security agent present in the $THREE town.

The entire stack is open-source on GitHub.

What you can take with you, and try today

The promise of the session was a clear model of how to design, build, and ship a 3D AI agent, plus the resources to start right after. Here is the shortest path, and most of it needs no wallet.

• Spin up a 3D agent from a prompt at three.ws/forge
• Embed it with the agent-3d Web Component or the React library, in one line.
• Give it a brain, and govern it with Granite Guardian before it ever sends value.
• Give it tools by pointing your Model Context Protocol client at the three.ws servers, including npx -y @three-ws/ibm-watsonx-mcp to run Granite on your own watsonx.ai account, or npx -y @three-ws/ibm-x402-mcp for pay-per-use.
• Let it transact with x402, in United States Dollar Coin or THREE on Solana
• Build on it with npm i @three-ws/forge and the rest of the suite, to wire text-to-3D, payments, voice, and identity into your own product.

Have a question about building on Granite, watsonx.ai, or the integration patterns above? Drop it in the comments.