A dedicated animation workbench + live tool streaming

Split and stream: make big tools focused, make waiting transparent

The day's two through-lines are both about clarity. One is splitting an ever-bloating big workbench into focused tools — big-and-everything often means nothing is quite smooth, and after splitting each can be more focused and go deeper. The other is turning the agent's tool-calling from "a black box you wait on" into "watching it work live" — making waiting transparent so you can see which step it's on. One is structural clarity, the other process clarity; with preview stability polish and several new engine capabilities, the day's overall work is keeping this ever-larger system clear and controllable to people.

The character workbench splits: character, animation, effects each focused

The original character workbench carried too many responsibilities — modeling, animation and effects all piled together, growing bloated with no room for any to stretch. This day split it by function: animation-related capabilities (skeletal animation, video generation and related pipelines) moved out wholesale into a dedicated animation workbench; effects-related capabilities (various visual-effect generation) moved into a separate effects/skill workbench; and the character workbench itself slimmed back to "focusing on the character." The split was careful — shared low-level code was carried over with clear annotations so that afterward the tools don't depend on each other and can each evolve independently. With clearer division of labor, each tool is more focused and usable, and each can go deeper in its own direction without one change rippling through everything.

Tool execution streams live, then tidies itself away

When an agent calls a tool, the process now streams live — output rolls out line by line so you can watch it progress instead of waiting blankly for a final result. Behind this, the backend gained "incremental streaming output for tool calls": a tool pushes fragments to the interface in real time as it runs, rather than holding everything until it finishes. To avoid flooding the screen, the display keeps a "rolling tail" of just the latest lines; when the step finishes, its tool panel auto-collapses and the interface returns to clean at once. This improves the "waiting experience": while waiting on a tool that may run for tens of seconds, seeing it genuinely move and knowing which step it's at is far more reassuring than staring at a frozen spinner. Transparent while you watch, out of the way once you've seen it — exactly the discretion a good tool should have.

A steadier preview: crash prevention + removing the redundant overlay

Preview stability got another pass this day. The key piece: before reloading the preview, it now "gracefully" releases the graphics resources held earlier and then loads the new one — avoiding old and new rendering both grabbing resources and crashing the whole graphics environment. Crash detection got smarter too, changed to "start judging only after the first frame appears," dodging false alarms during the just-loaded, not-yet-rendered window. The somewhat redundant crash overlay was removed — if you really need to start over, the toolbar already has a reload button, which is enough. Streaming output also got throttling to avoid refreshing too fast and dragging down rendering. Individually fine-grained, these together decide one thing: whether, as you repeatedly try and edit in the preview, it keeps crashing on you. Eliminating these small crashes one by one is what keeps creation uninterrupted.

Engine: an audio system + material inheritance + advanced rendering demos

The engine filled in several pieces this day. Most notable is the audio system — the engine wired in a sound system based on the web's standard audio capability, so games can now make sound: background music, sound effects and scene-driven audio all have underlying support; a game with no sound always lacks half its soul, and this step adds the "hearing" dimension. On materials, inheritance from a "parent" material was supported: put shared settings on the parent, and a child overrides only what differs, making a batch of stylistically-unified-yet-slightly-varying materials both manageable and less error-prone; material registration was also unified. On rendering demos, a batch of advanced-technique demonstrations (depth, stencil, blending, culling, etc.) was completed — both living documentation of the engine's capabilities and a template for more complex visual effects later.

What this day means

This day worked on "staying clear after growing large." Splitting tools admits "one tool can't do everything," so let the specialized specialize; streaming execution admits "users have the right to see what the AI is doing," so make it transparent; preview crash-prevention and engine audio plus material inheritance smooth roughness and fill gaps in their own corners. What a system most easily loses while expanding fast is "clarity" — features pile up, tools get tangled, the process becomes a black box. This day went the other way: rather than keep stuffing one big tool, split it so each is clean; rather than let waiting be a black box, lay the process open for people. Staying clear is the precondition for a complex system to be trusted and steered long-term.