I build robots that learn to walk, grasp and follow instructions in simulation, and then I test them until they fail. I care less about a good demo than about knowing why a system breaks: every result I publish comes with its trial count, its seeds, its failure cases and the script that produced it.

• 🎓 BSc Mechatronics & Robotics, German University in Cairo
• 🤖 Focus: reinforcement learning for locomotion and whole-body control, vision-language-action (VLA) models, world models
• 💻 Compute: everything below was trained on one 6 GB laptop GPU (RTX 3060)

A robot dog with an arm hears a tool request, walks to the workbench, finds the tool, picks it up and brings it back, and says something useful when it can't.

• Grasping: 125/125 (5 tools × 25 trials, while standing on its legs)
• End to end: 60/70 (86 %) over 7 scenario suites × 10 seeds; 8 of the 10 failures are falls on a step, not manipulation
• Learned policy: a fine-tuned SmolVLA went from 0/20 to 18/20 grasps on held-out scenes after a step-by-step diagnosis of why it failed

Stack: MuJoCo · RL walking policy · Qwen3-VL for finding objects · SmolVLA / LeRobot Code & full results →

The usual recipe for robust walking mixes random pushes during training with domain randomization. I trained three Unitree G1 policies that differ only in that, then shoved them 22,000 times.

• Pushes do the work: the force the robot survives half the time rises from 337 N to 639 N
• Domain randomization adds only 2.4 % on top
• Includes a bug in my own evaluation that I found, fixed and documented (it was hiding the falls)

Stack: MuJoCo / mjlab · PPO · 4,096 parallel robots Code & full results →

Two OpenArm v2 arms pick up a tray and carry it while keeping a loose ball from rolling off, using only two camera images, with real collisions and nothing glued in place.

• 12/12 carries with camera noise, 40 ms latency, backlash, weak motors and randomized dynamics all at once (12 randomized layouts, fixed seeds)
• Without the balancer: 1/12
• Try it in your browser → (real MuJoCo physics, shove the ball yourself)

Code & full results →

• RopePhysics: a C++/CUDA rope and cable simulator checked against textbook physics; a learned policy routes 1024/1024 new wire harnesses where a hand-written one routes none.
• Warehouse humanoid: a G1 carrying a 4 kg tote (0/64 falls), planned by a small local vision-language model, with its breaking points mapped (latency, shoves, friction, motor strength).
• Baglens: checks whether a robot recording can be trusted before anyone debugs from it; published precision/recall, runs as an MCP server.
• Jointly: a desktop app that turns CAD into simulation-ready URDF, MJCF, SDF and USD robot models.
• Humanoid triple backflip (private): a G1 runs off a cliff, does three backflips across the gap and lands running; 100 % strict success in evaluation with motors boosted to 2× torque.

Foresight: a Unitree G1 with real Dex3-1 hands follows language instructions ("put the red mug on the shelf"), grasping with actual finger contact. A VLA model drives an RL whole-body controller, and a learned world model imagines the next 1–2 seconds and blocks actions predicted to fall, collide or drop the object.

• unitree_rl_mjlab (Unitree): dependency bounds that keep fresh installs working
• ros2_medkit: fault debouncing and diagnostic-data fixes for ROS 2 robots

Looking for robot learning, RL and simulation roles. Let's talk on LinkedIn →