AxisLab

Inspiration

Robotics students often learn Denavit–Hartenberg parameters as abstract tables and formulas. It can be difficult to understand how changing θ or d actually moves a robot, affects downstream coordinate frames, and changes the end-effector pose.

We created AxisLab to connect mathematical notation with visible motion. Instead of returning only a textual explanation, AxisLab turns a learner’s natural-language question into a verified, interactive robotics experiment.

What it does

AxisLab is a Qwen-powered multi-agent robotics learning environment.

A learner can request a robot or ask about a robotics concept in natural language. A Pedagogy Agent defines the learning objective and evidence criteria, while an Environment Agent produces a constrained robot topology and activity. A deterministic Verification Agent checks the result before it reaches the browser.

Students then follow a prediction–manipulation–explanation learning cycle. They can:

Predict whether a joint parameter causes rotation or translation.
Manipulate revolute and prismatic joints in an interactive 3D scene.
Observe synchronized DH parameters, transformation matrices, coordinate frames, and end-effector positions.
Explore Cartesian, cylindrical, and spherical coordinate systems through dedicated interactive visualizations.
Submit an explanation and receive evidence-based feedback.
Inspect a trace showing how the agents generated and verified the lesson.

If the model output is rejected or the provider is unavailable, AxisLab safely switches to a human-verified fallback lesson.

How we built it

The frontend is built with Vite, React, TypeScript, and Three.js. It renders interactive serial robots, coordinate frames, DH tables, transformation matrices, and coordinate-system explainers.

The backend uses FastAPI, Pydantic, and SQLite. Qwen, accessed through Alibaba Cloud Model Studio, powers the Pedagogy and Environment Agents. Trusted Python code performs schema validation, standard-DH forward kinematics, renderability checks, and activity verification.

The agents never generate executable frontend or backend code. They produce structured data under strict contracts, which is validated before a trusted renderer converts it into a scene.

AxisLab is deployed on Alibaba Cloud ECS. Nginx serves the Vite application and proxies API requests to a private FastAPI service managed by systemd.

Challenges we ran into

The main challenge was making generative AI reliable enough for an interactive mathematical environment. A response could sound correct while containing incomplete JSON, an incorrect joint order, invalid parameter ranges, or an activity that did not match the generated robot.

We addressed this by separating pedagogy, environment generation, and verification into explicit roles. Rejected proposals receive structured issue codes and one revision attempt. If verification still fails, the system loads a verified fallback instead of exposing an invalid lesson.

Another challenge was keeping the 3D robot, DH table, local matrices, total transform, and end-effector position synchronized. We implemented independent frontend and backend kinematic calculations and compare their results with a tolerance of 1e-6.

We also designed the interface to remain usable across different screen sizes while presenting a large amount of mathematical and visual information.

Accomplishments that we're proud of

We are proud that AxisLab is more than a chatbot or a fixed animation. It can compile natural-language requests into verified mixed revolute/prismatic robot lessons while preserving a clear safety boundary between model output and trusted code.

In our reproducible four-case benchmark, a direct single-agent baseline produced 0/4 complete valid robot packages. AxisLab’s Agent Society produced 4/4 exact topologies that passed the same deterministic verifier without fallback. Its recorded median latency was also reduced from 15.08 seconds to 13.82 seconds.

We also completed a public deployment on Alibaba Cloud ECS, implemented persistent learning evidence and agent traces, and added interactive Cartesian, cylindrical, and spherical coordinate-system lessons alongside the robot visualizer.

What we learned

We learned that multi-agent architecture is most valuable when each agent has a narrow responsibility and an independently testable contract. Simply adding more agents does not guarantee reliability; deterministic verification and controlled fallback behavior are essential.

We also learned that AI-generated educational content becomes much more meaningful when it is connected to observable actions. Capturing predictions, parameter changes, and explanations allows feedback to be grounded in what the learner actually did rather than generated from the question alone.

Finally, we learned that mathematical visualization requires a single, explicit convention. Using standard DH consistently across the backend, frontend, prompts, validation rules, and interface prevented many subtle errors.

What's next for AxisLab

Next, we plan to add inverse kinematics, dynamics, collision detection, and additional robot families. We also want to support adaptive lesson sequencing based on learner evidence, instructor dashboards, classroom assignments, and larger evaluations of learning outcomes.

Future versions could provide multilingual instruction, reusable lesson libraries, and collaborative exercises in which students compare different robot configurations. We also plan to add a custom domain with HTTPS and expand the benchmark across more models, prompts, and repeated runs.