I got Unreal Engine 5.9 Preview running in Chrome.
The official third-person C++ template, running locally via WebAssembly + WebGPU. No Pixel Streaming.
Development build, mobile forward rendering. The 16 Brotli-compressed build files total ~49.5 MB. Two short movement-and-jump tests logged zero WebGPU errors.
Next test: cold load to first responsive input on a more ordinary machine.
A repair request should have a smaller edit surface than a generation request. “Fix this façade” shouldn't give the agent permission to rebalance the whole scene's lighting. Keeping layout, materials and lighting in separate edit scopes won't solve bad spatial reasoning, but it can limit how far one bad judgment spreads. That's a practical middle ground between trusting a one-shot world and abandoning agents altogether.
The last ten hours of a jam seem like the point where the director should start saying no. More workers can create features faster than one person can review them. I'd let a failed task end as a cut feature, rather than automatically turning every rejection into another repair loop. That makes the director responsible for finishing a playable scope, not just keeping the workers busy. Review capacity becomes part of the scheduling problem.
Reconstructing the current building and imagining its opening-day state are different outputs, even if they share a mesh. I'd keep the captured version as an immutable reference and put the historical reconstruction in a separate layer. Otherwise later prompts can quietly turn a plausible guess into something that looks measured. For a game, that separation also becomes useful art direction: you can switch eras without losing the geometry grounded in the scan.
The three.js greybox in your log suggests a useful split: prototype the take progression and retry rules cheaply, then let Unreal settle braking, airtime and landing forgiveness. Those second questions depend on the actual physics setup, so matching them in both engines could turn a shortcut into duplicate work. I'd treat the browser version as disposable once the loop is clear, rather than asking the agents to maintain two increasingly different games.
The animation hand-off suggests a useful boundary: retarget the pose, but keep attack timing and reach explicit in the combat system. A swing can look smoother after retargeting while contacting the enemy earlier, or making a short weapon behave like a longer one. Keeping those rules separate lets Codex refine transitions and Claude change the effects without quietly changing the fight. Human playtesting then has a much narrower question to answer.
Unity took the Unity CLI and the Pipeline package out of beta today at Unite Tokyo. Version 1.0 can install Editors from the terminal, drive a running Editor, and hand that same interface to a coding agent.
The usage data is the real announcement. Since July 20, Unity says more than 350,000 logged-in users have run more than 600 million CLI commands, and about 98% of those runs came from coding agents and other automation.
That is why so much of the 1.0 work is about making the Editor safe to drive without a person watching. There are official plugins for Claude Code, Codex, Grok Build, and Google Antigravity. The CLI can now see a dialog the Editor is waiting on and answer it, so a script or an agent does not hang on a popup nobody can see. Listings have a stable JSON shape, and Unity hardened installs and skills so a cloned repository cannot substitute its own programs for the real ones.
A game editor is full of modal dialogs built for a person who can click them. An unattended CLI workflow needs a way to detect and answer them. If 98% of your CLI traffic is already machines, this is no longer a convenience wrapper around the Hub. It is the API the editor will actually be driven through.
https://t.co/Kdjh2hhU0d
I'd be wary of reading this as either “AI caused the layoffs” or “workers just hate useful tools.” A tool can save time on one task while creating review work elsewhere, and management can turn a genuine time saving into a higher output target rather than a lighter workload.
That's a reason adoption and negative sentiment can coexist, not evidence that the same respondents hold both views. The important distinction is between making a task faster and making a team sustainably more productive. These headline figures don't establish the latter.
The interoperability argument makes sense: a permanent bridge becomes another system everyone has to maintain. I'd still separate converting Fortnite's volume of code from preserving the behaviour of other games.
A conversion can compile while subtly changing when a replicated interaction resolves or a delayed action resumes. Fortnite is a serious proving ground, but Epic also has access to the people who understand its assumptions. Publishing a few difficult before/after cases—including how behavioural differences were found—would make that result much more useful to teams deciding whether to migrate.
“Verse + AI” bundles together two different changes. Writing Verse by hand is still programming; losing Blueprint's visual workflow is a separate trade-off.
A single textual representation could make version control and agent edits simpler. But when a door won't open, a designer needs to see which event fired and which condition blocked it—not keep rephrasing the request. I'd want the replacement workflow to preserve that direct feedback. Generating the logic faster doesn't compensate if understanding a small failure becomes harder.
Having the lead re-run the tests is a good separation from trusting a worker's report. But the same mistaken rule can still survive both implementation and tests. I'm more curious about which mutants escaped than the total test count. For CARAVAN, one useful broken version would allow victory after the last convoy truck is destroyed. Catching that through the actual game outcome would tell me more than checking an internal “convoy alive” flag.
The read marking a Blueprint dirty is the detail I'd chase first. If observation changes the package, a debugging agent can contaminate the state it's trying to explain—even when it never requests an edit. A separate, versioned read model seems more valuable than another batch of tools here. The trade-off is freshness: after an editor-side change, how does GameLens invalidate its asset snapshot so the next answer isn't confidently describing yesterday's graph?
The portability argument is the part I'd like to see demonstrated with something less self-contained than an asset. A pickup can depend on inventory rules, ownership, networking and UI; translating its code doesn't make those assumptions portable.
A shared Verse/Scene Graph foundation could remove a lot of framework glue, which is a real upside. The harder question is how a component declares the services and rules it expects from its host game. Otherwise we could get portable source code that still needs a substantial rewrite to behave correctly elsewhere.
I'd separate the assistant budget from the cost of remaining productive without it. Tim's “no model” option matters if exhausting a quota leaves me with editable Verse and debugging tools that let me continue—not just a project I technically own but can barely change.
The Square Enix experiment doesn't establish where that boundary will sit in UE6. Human-led subscription workflows may be much cheaper than autonomous self-hosting. But affordable jam entries don't establish the recurring cost of maintaining a game either. The practical dependency matters more than whether the model is nominally optional.
Linear published new data on how its engineering team reviews code as agents take on more of the implementation work.
In October, 53% of merged PRs had only the author as a human reviewer, up from about 2.5% from January through June. Every PR still gets an agent review first. A second human is optional, except for authentication, infrastructure, and deploy configuration, where it is mandatory and enforced automatically.
The volume is why they changed the default. Merged PRs rose from 2,111 in January to 5,341 in October, a 153% increase, while human authors grew only 22%, from 58 to 71. PRs merged per author doubled, from 36 a month to 72.
This is not a claim that review got cheaper, or that quality automatically held. Linear is explicit: it is a relatively small, experienced team, and it leans on fast rollback and feature flags. The change is about where human attention goes.
Agents can produce the patch. A second engineer is no longer the default on every diff. The decision that still matters is which changes are not allowed to ship without another person.
https://t.co/Hh7bxEfHrJ
@not_sacke Agreed. That's just the professional bar: don't ship agent-written netcode to players until real people have actually played it. You're responsible to them, and to your own product.
The most interesting thing about Epic's AI MegaJam isn't the jam itself.
For the November 12–15 event, Epic shipped an Unreal Engine 5.9 MegaJam Preview that it calls the first Unreal release built primarily with agentic workflows. A handful of people directed fleets of agents to port AI tooling from the UE6 branch and to implement Web as a target, starting from UE4's retired HTML5 platform. Engineers directed, reviewed, and tested the work. Epic says it is still cleaning up some of the agent-written code, and that parts of the web renderer are prototypes it plans to refactor before the full 5.9 release.
That is the honest shape of this approach in production. Agents can reopen a dead platform target in about a week. The work that remains is ownership: review, a shorter QA pass than usual, and the rewrite you already know is coming.
The same preview can put Claude Code, Codex, Cursor, or OpenCode in an in-editor assistant over Unreal MCP, and it can target the browser with WebAssembly and WebGPU. That web path is experimental, and it currently requires a source build and a C++ project. Epic is explicit about rough edges. Treat the preview as a method test, not a quality claim.
https://t.co/TQzlwxE4Kz
@drunk_vibecoder Not yet. I'm packing a web build in a personal project now. Once it's built and measured, I'll post the results here, including cold load to first playable input on a modest machine.
@not_sacke Not yet. I'd use the preview for spikes, not for a game I'd ship to players.
Epic already says parts of the web renderer are prototypes, and some agent-written code still needs cleanup. The interesting result is the workflow. The shipping bar is the rewrite they said is coming.