Hy4: Two Games, 185 Steps, and 51 Tests It Wrote Itself

Hy4 launched today. I gave it two builds and stayed out of the way. Both arrived working on the first version.

That first sentence is why I sat down to write this: a coding agent that lands a runnable deliverable on attempt one changes how you plan your day.

I picked the builds to be hard. Full projects from a paragraph of prompt, an empty directory, and every asset generated in code.

What Hy4 is

• 770 billion total parameters, 49 billion activated per token. A sparse mixture-of-experts design, which means the model is large while the slice that fires for any given token stays small. That gap explains the speed.

• Two thinking speeds. reasoning_effort: "high" makes the model think first and hands the thinking back in a separate reasoning_content field. reasoning_effort: "no_think" goes straight to the answer.

• 665,536 output tokens by default, reaching 1,000,000 in context. A million tokens in context covers a whole project rather than a long answer

• OpenAI shaped API. Standard chat completions, standard function calling. Any harness that speaks OpenAI speaks Hy4.

• Text in, text out. Hy4 works in text, so keep your verification loop in text too.

Set the model ID directly in your config, since discovery lives outside the API.

Tencent positions Hy4 as a step up from Hy3 on multi step agentic workflows, software development and productivity work, with better task decomposition, context retention, instruction following and long horizon execution. The coding claim calls out game development and web development by name, which is exactly what I set out to test.

The five capabilities Hy4 is built for

Tencent frames the model around five core capabilities:

The official guidance for judging coding agents points at cross platform full stack work across web, mobile and desktop, complex back end logic, and 3D rendering. For productivity work it points at deep research, presentation design and spreadsheet accuracy.

One line in that framing turned out to matter more than the rest. Under long horizon execution, the stated measure includes self verification before delivery. Keep that in mind for the last section, because I watched it happen.

The Crash game

Hy4
116 steps
In 193,793 · Out 53,328 · Reason 73,349
Cache R 10,664,768 · W 0 · Hit rate 98.2%

The brief: a side scrolling platformer in the spirit of the 32 bit mascot era. Native HTML5 Canvas, engine free, with collision, gravity, run acceleration, breakable crates, a spin attack, checkpoints, death and respawn.

Hy4 shipped three files. index.html, style.css, and 1,634 lines of game.js.

Packed into that single script: a menu system with an options panel and a placeholder password screen, a tile based level builder, a fixed timestep game loop, ground probing, per axis collision resolution, coyote time on jumps (a short grace window where a jump still counts just after you leave a ledge), crate physics across several crate types including TNT, an Aku Aku style pickup mask, fruit collectibles, gem tracking, patrolling crab enemies, spike and water hazards, checkpoints with respawn, a particle system, procedurally drawn palm trees over a parallax ocean, a live FPS readout, on screen touch controls for mobile, and pause, complete and game over overlays.

The audio is built at runtime through AudioContext. Every sprite is drawn with Canvas primitives. Roughly forty separate functions, and every asset generated in code.

One point of accuracy worth stating plainly: this build renders through the 2D canvas context. The sense of depth comes from layered parallax and shading rather than WebGL, which is arguably the harder craft.

The Spider-Man character

Hy4
69 steps · $0.00
In 167,511 · Out 36,531 · Reason 60,246
Cache R 5,678,848 · W 0 · Hit rate 97.1%

The brief: one 3D character, modelled and textured and rigged and animated, in Three.js. A Spider-Man style figure that walks, runs and jumps. Build the mesh in code.

Hy4 shipped a running prototype with a dependency free static server, a README, and a test suite.

• Mesh. A single SkinnedMesh, 9,739 vertices, one draw call. Assembled in code from capsules, ellipsoids and boxes covering head, neck, torso, pelvis, arms, legs, boots, gloves, mask lenses and a chest emblem, standing about 1.9 m tall.

• Texture. A 256 by 256 spider web lattice painted onto a canvas at runtime and tiled 3 by 3. Per vertex colours carry the suit palette. Final colour works out to vertexColor × webTexture under a MeshStandardMaterial.

• Rig. A 22 bone skeleton running Hips → Spine → Spine1 → Chest → Neck → Head, plus mirrored arm and leg chains. A pose bind, world matrices resolved ahead of skeleton construction, identity bind matrix.

• Skinning. Weights worked out per body part with a smooth (1 - (d/r)²)² falloff, keeping the four strongest influences and normalising them to 1.

• Locomotion. Walk at 1.53 m/s, run at 5.2 m/s, gravity at 22 m/s², and a jump state machine of crouch → air → land with a 1.25 m apex on an edge triggered key, so holding the button gives you a single jump.

• Animation. Procedural FK posing that eases between idle, walk, run, air, crouch and land. Gait phase runs off distance travelled, 1.45 m stride walking and 2.9 m running, so footfalls match ground speed instead of sliding. A contact pass keeps the standing foot on the floor.

On screen it reads clearly as the character: red mask, blue torso, red gloves and boots, the web lattice visible across every panel, casting a real shadow onto the ground plane. It also reads as a prototype, with a capsule and ellipsoid shape and dark default lighting.

Reading the ledger

Two figures in those telemetry blocks carry more information than the step counts.

Hy4 thinks more than it types

Six of every ten tokens Hy4 generated were invisible to you. On the more mathematical task, with skinning falloff and bone hierarchies and gait phase to work out, the ratio climbed to 1.65 reasoning tokens for every output token.

That spend is the mechanism. The character rig arrived correct, with normalized weights and finite transforms and feet on the floor, because the model spent 60,000 tokens working through matrix order before writing the file.

Budget for the thinking. It accounts for most of what you pay and most of why the output holds up.

The cache does most of the work

Across both builds Hy4 processed roughly 16.7 million tokens of context while fresh input totalled 361,304 tokens. Hit rates held at 97 to 98% across 185 steps.

This is what long horizon agent work looks like from inside. Every step reads the whole conversation again, averaging 91,938 cached tokens per step on the Crash build, and the cost of the whole run depends on that repeat reading staying close to free. At 98.2%, it does.

Cache writes report zero in both runs, so treat the cache column as a read side view rather than a full account.

Breadth costs steps, depth costs thinking

The Crash game took 116 steps. The Spider-Man character took 69.

I expected the reverse, since rigging a skinned mesh with correct weight normalization sounds like the deeper problem. The Crash build is simply wider: forty functions, a dozen entity types, menus, audio, mobile controls and level design.

The per step figures show it. The character build generated 873 reasoning tokens per step against 632 on the platformer. Fewer steps, harder thinking inside each one.

The part that stands out

Remember that line from the official framing, the one about self-verification before delivery. Here is what it looks like in practice.

Hy4 works in text, so when the brief is visual, it reaches for the one form of proof available to it. It writes tests.

The character prototype shipped with a headless smoke suite of 51 checks across the rig, the skinning, the poses, and the movement. I ran it cold:

$ npm test
...
51/51 checks passed

Assertions rather than opinions. Every vertex carries four normalized weights summing to 1. Head vertices resolve to head and neck bones. Rotating Thigh.L moves the foot while the head holds still. Through idle, walk, and run, the standing foot sole stays on the ground, ankle at roughly 0.03 m. Jump apex measures 1.250 m against a configured 1.25. Holding the jump key mid-air gives exactly one jump. Bone transforms stay finite across long sessions.

Beside the suite sits a ten-point human validation checklist in the README, covering the parts a test leaves open. Does it read as the character? Does the run blend back into the walk cleanly? Does releasing the keys settle into an idle breathing pose?

That split is the interesting behaviour. Hy4 sorted the brief into things it could prove and things a person has to judge, then shipped the proof for the first group and named the second group plainly. A test suite beats an opinion, and Hy4 built the suite on its own.

What impressed me

• First version quality. Both deliverables ran as delivered. The smoothness of that first pass is the thing I keep coming back to.

• Speed. For 770 billion parameters, the turnaround feels much quicker than the headline number suggests. The 49 billion active slice pays off.

• It finishes. 116 steps and 69 steps keeping track of the brief and staying coherent through to delivery.

• Clean tool selection. Right tool, right arguments, first attempt, across every test I ran.

• Real self verification. Hy4 shipped proof that the rig was correct, and the proof passes.

What to plan for

• Keep the loop in text. Verify through assertions and logs.

• Set the model ID directly. Discovery lives outside the API.

• Size your budget for reasoning. Expect roughly 1.4 to 1.7 times your output volume in invisible thinking.

• Read the cache column as read side only. Cache writes report zero.

• Prototypes arrive as prototypes. The character is geometrically correct and visually rough. Correct and polished are separate goals, and the second one stays with you.

• Choose the harness with care. Agent frameworks tuned tightly to one vendor's patch format will make that vendor look better. Test the model rather than the adapter.

Verdict

Two games. 185 steps. 16.7 million tokens of context processed, 584,758 tokens generated fresh. Two things that run.

Hy4 surprised me, and the surprise came from reliability rather than a clever demo. Both deliverables worked on the first version, the effects landed smoothly, the tests it wrote for itself pass, and the whole thing moved quickly.

Hy4 works in text. It built a Spider-Man anyway, checked its own work 51 ways, and handed me a clear list of the ten things to look at myself.