Inline 3D & image preview + @-mention pills

Making collaboration visible and clickable

In the prior days the platform built the capability of "multiple agents running long in the background + an event bus," but all of it was still hidden inside the system. This day's through-line was pushing that capability fully to the interface foreground: you can not only see the traffic between agents on the bus, but @ a specific agent by name, preview assets in place, and bring objects into the conversation as reference pills. In other words, what this day added isn't an isolated feature but the interaction layer that makes "a team of agents collaborating" something an ordinary person can actually operate. Once the backend's complexity is translated into interface elements you can read and click, multi-agent goes from "technically runs" to "comfortable to use."

@ an agent to talk to it directly

Multi-agent collaboration took a key step this day: you can @ a specific agent by name in the conversation so it picks up that message and replies, rather than only talking to the lead and having it relay to others. A companion agent-hub panel went live, presenting at a glance which members are in the current "team" and what each is busy with. What this changes is the "command style" of collaboration: where you used to be able to speak only to the project manager, you can now go past the manager and address the member handling art, or the one handling levels, directly. For the core scenario of "one person leading a team of AIs," named communication is the watershed from "broadcast" to "precise command" — you can finally say the right thing to the right member.

Bus status spread across the UI: capability health everywhere

Building on the prior day's wiring of the bus into the interface, this day spread "which capabilities exist in the system and how healthy each is" into every corner of the UI. The top bar gained a row of status lamps for categories like tools, skills and agents, each showing a count and health; the chat panel, sidebar and bus admin panel are likewise dotted with this "little lamp + count + clickable deep-link" presentation, where one click jumps to the matching detail. Its value is turning "what does the system have right now and how is it doing" into ambient information — you don't go look it up; a glance at the interface tells you. For a system with ever more capabilities, extensible by plugins, this omnipresent health visualization is key to always having a feel for "what state it's in."

Inline asset preview + reference pills in chat

This day also made "assets" visible and referenceable in conversation. Chat can preview attachments in place: paste an image and get a thumbnail; drop a model file and it renders as a small viewable preview, without first wiring it into a running game to see what it looks like. When discussing a character or a texture, both sides see the same concrete thing rather than imagining their own. The companion "reference pills" let you type @ in the composer to turn an agent or a resource into a clickable tag — remembering what you used recently, showing a tooltip on hover, clickable back after insertion. Together, these turn "bringing an asset into the conversation" — which used to mean copying long paths and describing in words — into a direct drag-and-click action.

Engine: a unified mesh renderer + material handle + default-value fallback

The engine made important convergences at the rendering and component layers this day. In rendering, it unified to a single mesh renderer that references materials by a "material handle" — that is, how an object is drawn is uniformly described by "a mesh plus a handle pointing to a material," both clear and easy to reuse one material across objects. On components, "creating an entity" and "adding a component" gained a default-value fallback chain: when you don't explicitly set a field, the system walks layered rules to find a sensible default rather than erroring or leaving it blank. This means writing game content can be "write only the parts you care about, leave the rest to sensible defaults," greatly cutting boilerplate and error surface. Such convergence isn't a new feature but the key to the engine staying "low-surprise, predictable" as more people (and AI) use it.

Engine: unified capture + console dependency inversion + tutorial examples

The engine also cleaned up several spots of "duplication" and "coupling" this day. One: the "screenshot" logic once scattered across multiple examples, each its own copy, was unified into a standard renderer capability — one implementation usable everywhere, cutting duplication and making visual verification more consistent. Two: the "console" debug channel got dependency inversion — it no longer depends directly on concrete internal modules but works through an abstract interface, decoupling them — letting the console evolve more independently and letting plugins plug in a uniform way. Three: a full set of progressive rendering tutorial examples landed (from the most basic triangle and textures to input handling), and common capabilities like images, textures and input were internalized into the engine itself. These examples are both living documentation of the engine's capabilities and the best entry point for newcomers (and AI) to learn how to use it.

What this day means

The day's two lines — fully "revealing" multi-agent collaboration in the interface, and heavily "converging" rendering and components in the engine — seem unrelated but inside share one pursuit: keeping a rapidly-complicating system clear to people. On the interface side, @-mentions, capability health lamps, asset preview and reference pills together turn "directing a team of AIs" from abstract into concretely operable; on the engine side, the unified renderer, unified capture, dependency inversion and tutorial examples together keep the low level from growing messier as features balloon. A system that can evolve long-term must both grow outward in capability and keep order inward — and this day did exactly both at once.