How Chinese Large Models Really Perform on Interactive Frontends and Agent Tasks
This article examines how Chinese large models actually perform when asked to build interactive frontends and complete agentic tasks, such as webpage generation, sliding-block puzzles, 3D bowling-style scenes, and reinforcement learning maze visualizations. It shows that while these models can produce good-looking prototypes, visual polish often hides weak functionality, flawed spatial and geometric reasoning, unstable interaction, and inconsistent results across runs. The article explains how to separate three levels of completeness—visual, interactive, and business logic—and recommends acceptance criteria, staged generation, a unified state model, and multi-run testing so that models move from "looks done" to something verifiable, maintainable, and reproducible.
In recent years, the way we evaluate large models has shifted from “can it answer questions?” to “can it complete complex tasks?” This is especially true in scenarios like webpage generation, browser automation, 3D scene construction, mini-game development, and reinforcement learning visualization. In these cases, a model has to do more than output text or code: it must understand the task goal, plan the execution steps, call tools, generate the page, and verify the final result.
From hands-on experience, some Chinese large models already have fairly solid general capabilities. They can produce visually appealing webpages, implement simple interaction logic, build basic 3D scenes, and even create reinforcement learning demos with a visible training process. But once the bar moves from “the page looks right” to “functionally complete, logically correct, stable to interact with, and reproducible,” the problems become much more apparent.
1. Visual generation is mature, but “good-looking” is not the same as “correct”
In terms of visual presentation, many models can already generate gradient backgrounds, light-and-particle effects, dynamic cards, glowing buttons, and complex layouts. For ordinary showcase pages, these results are often enough to look like a complete product prototype.
However, visual completeness can easily mask functional gaps. A page might have refined colors and animations yet still suffer from problems like:
- Key buttons with no actual event handlers;
- Animations that just loop on their own, unrelated to user actions;
- Elements that overlap or get clipped at different sizes;
- Insufficient contrast between text and background;
- State changes that are not reflected in the UI;
- Components that appear to exist but cannot actually complete the task.
So when evaluating a model-generated frontend page, you can’t rely on screenshots or first-screen impressions alone. It helps to separate at least three levels:
- Visual completeness: whether colors, layout, hierarchy, and motion work together;
- Interaction completeness: whether buttons, drag-and-drop, keyboard, and mouse actions actually work;
- Business logic correctness: whether system state changes as expected after the user acts.
If “looks good” is the only standard, it is easy to overestimate what a model can really do.
2. Sliding-block tasks reveal a model’s spatial reasoning
Tasks like sliding-block puzzles (including the classic Klotski, or “Huarong Dao,” layout) look simple, but they test a model’s spatial understanding, state representation, and goal-checking all at once.
In these tasks, a model usually has to:
- Recognize the board’s row/column structure;
- Assign each block a unique position;
- Determine which moves are legal between the empty cell and adjacent blocks;
- Design a valid sequence of moves;
- Check whether the final layout satisfies the goal state;
- Map the internal state accurately onto a visual interface.
Some models do a good job arranging the blocks, which shows they have some grasp of discrete spatial layouts and basic state transitions. But sometimes a model will describe a particular visual style—ink-wash, wood grain, or paper texture—during its reasoning, while the final page never actually reflects it. This kind of mismatch shows that a model’s verbal reasoning does not necessarily match its actual output.
From an engineering standpoint, a model’s “chain of thought” should not be treated as system ground truth. A more reliable approach is to let the program verify the result through state variables, for example by representing the board as a 2D array:
board = [[1, 2, 3],[4, 5, 6],[7, 8, 0]]
Here 0 represents the empty cell. Whether the page shows the goal state should be computed by the program from the array, not described by the model itself. Visual style should likewise be implemented through explicit style rules, texture assets, or render parameters—not left at the level of natural language.
3. 3D bowling-style interactions expose gaps in geometry common sense
For 3D bowling or similar physics-interaction tasks, a model can usually generate a basic scene—balls, targets, a floor, lighting, and a camera. This shows the model can already apply common 3D rendering patterns and put together a runnable demo page.
But there is still a clear gap between “objects are visible” and “the scene obeys real rules.”
For example, targets might be spaced too far apart for the ball to hit more than one at a time; collision volumes might not match the visual models; the ball’s path might not align with the camera angle; and users can drag or click, but force, direction, and speed do not form any sensible relationship. These are not mere styling issues—they are problems of geometric modeling and interaction rules.
A basic 3D task needs at least the following parameters defined:
- The center coordinates of each object;
- Each object’s dimensions and collision radius;
- The proportions and scale relationships in the scene;
- The camera position and viewing direction;
- Initial velocity and direction of motion;
- Collision detection rules;
- Conditions for judging the goal state.
If a model just places objects based on visual intuition, it will easily produce a page that “looks like bowling” without satisfying basic physical common sense. A more reliable approach is to separate the scene into distinct layers:
- Visual layer: handles models, materials, lighting, and animation;
- Logic layer: handles position, collision, velocity, and scoring;
- Verification layer: checks whether the goal is reached—for example, whether all targets are knocked down.
This layering prevents a page that has only appearance and no truly playable mechanics.
4. Mazes and reinforcement learning better test agent capabilities
Reinforcement learning visualization inside a maze is a harder class of task than ordinary webpage generation. It requires the model to handle map construction, action decisions, value updates, the training loop, and UI synchronization all at once.
Problems that show up most often here include:
1. Map size doesn’t match drawing size
If the maze logic uses a small grid but the frontend mistakenly enlarges cells when drawing, the map can take up most of the page and even cover the control panel. The fix is to define grid coordinates and display coordinates consistently:
screenX = gridX * cellSizescreenY = gridY * cellSize
Here gridX and gridY come from the logical map, and cellSize is computed once by the layout system—rather than being estimated separately in each module.
2. The page doesn’t actually generate a runnable maze
Sometimes a model outputs a complete code structure, but because a variable is undefined, an event isn’t bound, the draw order is wrong, or initialization fails, the page ends up showing only a blank area. For agent tasks, “the code looks complete” means nothing—you must verify that the page can start, respond to input, and keep the training loop running.
3. The action layer isn’t aligned with the terrain layer
This is a very typical state-mapping error. The agent might act in one coordinate system while the map is drawn in another, so the agent appears to pass through walls, stop in the wrong place, or follow a trajectory that doesn’t match the visual map.
The recommendation is to use a single source of state data:
state = {agent: { x: 2, y: 3 },map: [...],qTable: [...]}
Drawing, actions, and training all read from the same state object, avoiding multiple separately maintained copies.
4. Training looks like it converges but is actually unreliable
Showing value numbers on the floor is a helpful visualization. It lets users watch how values change across positions and helps judge whether training is happening.
But “stable numbers” don’t necessarily mean the task was truly learned. The model still needs to verify:
- Whether the agent can actually reach the goal;
- Whether it often hits walls or falls into loops;
- Whether the post-training path is better than a random policy;
- Whether it still works from different starting points;
- Whether results stay consistent after re-initialization.
For tabular reinforcement learning, you can run multiple test rounds and measure success rate, average steps, and collision counts—rather than just watching a single animation round.
5. Differences across attempts reveal weak execution stability
In complex tasks, one successful generation does not mean the model has a stable capability. Real testing often turns out like this:
- The first attempt has badly distorted page proportions;
- The second attempt fails to generate a core component;
- The third attempt produces a page, but it can’t be interacted with;
- The fourth attempt has logic and visual layers out of sync.
This kind of variance suggests the model may have localized problem-solving ability but lacks reliable task planning and automatic verification. For an agent, stability matters just as much as peak capability. What businesses really care about is: if the same type of request is given to the model several times, do all the results meet an acceptable standard?
So model evaluation should use multiple rounds of testing, not just show the single most successful run. It helps to record metrics like:
| Dimension | What to watch |
|---|---|
| First-attempt success rate | Whether the first generation can start at all |
| Feature completion rate | Whether the main task can be completed |
| Interaction stability | Whether it still works after repeated actions |
| Visual consistency | Whether the logic state stays in sync with the UI |
| Fixing cost | How much manual correction is needed after errors |
| Reproducibility | Whether repeated runs produce similar results |
6. How to improve the quality of model-generated complex interactive apps
To raise the task success rate, the prompt shouldn’t just describe the final look—it should also state clear acceptance criteria.
A more complete task description should include:
- The page’s goal;
- The components that must exist;
- The interaction methods;
- The state data structure;
- Success and failure conditions;
- Exception-handling rules;
- Self-test steps;
- Items to check before output.
For example, instead of just saying “build a playable maze,” spell out further:
- The maze uses a fixed grid;
- The agent can only move within passable cells;
- The board is redrawn after each move;
- Training stops once the goal is reached;
- The page provides Start, Pause, and Reset buttons;
- If initialization fails, it shows a clear error message;
- Before output, it automatically runs one full-path test.
For complex tasks, staged generation also helps:
Stage 1: Build the logic model first
Implement only the map, state, actions, and goal check, without complex animation.
Stage 2: Add visualization
Map the logical state onto grid cells, colors, and text markers.
Stage 3: Add interaction controls
Add buttons, keyboard input, pause, and reset.
Stage 4: Run automated acceptance checks
Verify that the page starts, actions are legal, the goal is reachable, and the state stays in sync.
This is slower than one-shot generation, but it usually makes problems easier to locate and is better suited to engineering use.
7. Overall assessment: the strength is coverage, the weakness is reliability
From how these models perform on this kind of task, their current strengths mainly show up as:
- They can quickly put together page prototypes;
- They can combine visual effects with basic interactions;
- They can grasp the overall structure of common games or experiments;
- They can generate a fair amount of frontend code;
- On some reinforcement learning visualization tasks, they show an initial ability to model state.
But their weaknesses are equally clear:
- Natural-language descriptions don’t match the actual page results;
- They struggle with spatial proportions, geometric relationships, and physical rules;
- Complex pages easily suffer layout breakdowns;
- The logic layer, render layer, and interaction layer can drift apart from each other;
- They lack systematic self-testing and error recovery;
- Results vary considerably across runs.
So judging whether a large model is “strong” can’t rely only on whether it can generate a flashy page, nor on whether one particular demo succeeded. A more useful standard is: can it break a requirement into executable steps, keep state consistent, detect and fix errors, and reliably complete the goal across multiple runs?
For developers, the most practical way to use these models right now isn’t to abandon human verification, but to treat them as prototype generators, coding assistants, and debugging collaborators. For businesses, the answer is to build an evaluation system that includes functional testing, interaction testing, visual regression, and multi-run stability testing. Only by moving from “can generate” toward “verifiable, maintainable, and reproducible” can large models truly shift from demo tools into reliable engineering productivity.
