From Drones to Robot Dogs: How I Refactored a Manufacturing Engine in 88k Tokens

\ Recently, as part of my Gemini 3.0 challenge, I completed the OpenForge Neuro-Symbolic Manufacturing Engine. The system successfully designed, sourced, and simulated custom drones. But I wanted to push the model further. I wanted to see if the architecture was brittle (overfit to drones) or robust (capable of general engineering).

So, I gave the system a new directive: Stop building things that fly. Start building things that walk.

Incredibly, within just 88,816 tokens of context and code generation, the system pivoted. It stopped looking for Kv ratings and propellers and started calculating servo torque and inverse kinematics.

Here is how I used Gemini not as a Source of Truth, but as a logic translator to engineer the Ranch Dog.

The Fatal Flaw: The LLM as a Database

In my previous article I discussed the fatal flaw in most AI engineering projects: treating the Large Language Model (LLM) as a database of facts. If you ask an LLM, Design me a drone, it hallucinates. It suggests parts that don't fit, batteries that are too heavy, or motors that don't exist.

The solution is Neuro-Symbolic AI.

• Neural (The LLM): Used for Translation. It translates user intent: I need a robot to carry feed bags into mathematical constraints (Payload > 10kg).
• Symbolic (The Code): Used for Truth. Python scripts calculate the physics, verify the voltage compatibility, and generate the CAD files.

The LLM never calculates. It only configures the calculator.

The Pivot: From Aerodynamics to Kinematics

Refactoring a codebase from rigid-body drones to articulated robot dogs usually implies a rewrite. However, because of the Neuro-Symbolic architecture, the skeleton of the code remained the same. I only had to swap the organs.

Here is how the architecture handled the pivot:

1. The Brain Transplant (Prompts)

The first step was retraining the agents via prompts. I didn't change the Python service that runs the logic; I just changed the instructions Gemini uses to select the logic.

I updated prompts.py to remove aerodynamic axioms and replace them with kinematic ones. The system immediately stopped caring about Hover Throttle and started optimizing for Stall Torque:

# app/prompts.py REQUIREMENTS_SYSTEM_INSTRUCTION = """ You are the "Chief Robotics Engineer". Translate user requests into QUADRUPED TOPOLOGY. KNOWLEDGE BASE (AXIOMS): - "Heavy Haul" / "Mule": Requires High-Torque Serial Bus Servos (30kg+), shorter femurs. - "Fence Inspector": Requires High-Endurance, Lidar/Camera mast. - "Swamp/Mud": Requires sealed actuators (IP-rated), wide footpads. OUTPUT SCHEMA (JSON ONLY): { "topology": { "class": "String (e.g., Heavy Spot-Clone)", "target_payload_kg": "Float", "leg_dof": "Integer (usually 3 per leg)" }, "technical_constraints": { "actuator_type": "String (e.g., Serial Bus Servo)", "min_torque_kgcm": "Float", "chassis_material": "String" } } """

2. The Sourcing Pivot (Data Ingestion)

This was the most critical test. The system's Fusion Service scrapes the web for real parts. The scraper remained untouched, but I updated the Library Service to identify servos instead of brushless motors.

Instead of regex matching for Kv ratings, library_service.py now identifies whether a servo is a cheap toy (PWM) or a robotics-grade component (Serial Bus): \n

# app/services/library_service.py STANDARD_SERVO_PATTERNS = { # Micro / Hobby (PWM) "SG90": {"torque": 1.6, "type": "PWM", "class": "Micro"}, # Robotics Serial Bus (The good stuff) "LX-16A": {"torque": 17.0, "type": "Serial", "class": "Standard"}, "XM430": {"torque": 40.0, "type": "Dynamixel", "class": "Standard"}, } def infer_actuator_specs(product_title: str) -> dict: # Logic to infer torque if the Vision AI misses it if "est_torque_kgcm" not in specs: match = re.search(r"\b(\d{1,3}(?:\.\d)?)\s?(?:kg|kg\.cm)\b", title_lower) if match: specs["est_torque_kgcm"] = float(match.group(1)) return specs

3. The Physics Pivot (Validation)

In the drone build, physics_service.py calculated Thrust-to-Weight ratios. For the robot dog, Gemini rewrote this service to calculate Static Torque Requirements. It uses lever-arm physics to ensure the servos selected by the Sourcing Agent can actually lift the robot.

# app/services/physics_service.py def _calculate_torque_requirements(total_mass_kg, femur_length_mm): """ Calculates the minimum torque required to stand/trot. Torque = Force * Distance. """ # Force per leg (2 legs supporting body in trot gait) force_newtons = (total_mass_kg * GRAVITY) / 2.0 # Distance = Horizontal projection of the Femur lever_arm_cm = femur_length_mm / 10.0 required_torque_kgcm = (total_mass_kg / 2.0) * lever_arm_cm return required_torque_kgcm

4. The Simulation Pivot (Isaac Sim)

In NVIDIA Isaac Sim, a drone is a simple Rigid Body. A Quadruped is an Articulation Tree of parents and children connected by joints.

I tasked Gemini with rewriting isaac_service.py. It successfully swapped RigidPrimView for ArticulationView and implemented stiffness damping to simulate servo holding strength:

# app/services/isaac_service.py def generate_robot_usd(self, robot_data): # CRITICAL: Apply Articulation Root API # This tells Isaac Sim "Treat everything below this as a system of joints" UsdPhysics.ArticulationRootAPI.Apply(root_prim.GetPrim()) # Define The Joint (Revolute) representing the Servo self._add_revolute_joint( stage, parent_path=chassis_path, child_path=femur_path, axis="y", # Rotates around Y axis (swing) stiffness=10000.0 # High stiffness = Strong Servo )

5. The Locomotion Pivot (Inverse Kinematics)

Drones rely on PID controllers to stay level. Dogs require Inverse Kinematics (IK) to figure out how to move a foot to coordinates 

(x,y,z)(x,y,z)

Gemini generated a new 2-DOF planar IK solver (ik_service.py) that uses the Law of Cosines to calculate the exact angle the hip and knee servos need to hold to keep the robot standing.

# app/services/ik_service.py def solve_2dof(self, target_x, target_z): # Law of Cosines to find knee angle cos_knee = (self.l1**2 + self.l2**2 - r**2) / (2 * self.l1 * self.l2) alpha_knee = math.acos(cos_knee) # Calculate servo angle knee_angle = -(math.pi - alpha_knee) return hip_angle, knee_angle

The Result: 88,816 Tokens Later

The resulting system, OpenForge, is now a dual-threat engine. It can take a persona-based request: I am a rancher and I need a robot to patrol my fence line" and autonomously:

1. Architect a high-endurance quadruped topology.
2. Source real Lidar modules and long-range servos from the web.
3. Validate that the battery voltage matches the servos (preventing magic smoke).
4. Generate the CAD files for the chassis and legs.
5. Simulate the robot walking in a physics-accurate environment.

This pivot wasn't about the robot. It was about the Agility of Neuro-Symbolic Architectures as well as Gemini 3.0. By decoupling the Reasoning (LLM) from the Execution (Code), you can refactor complex systems at the speed of thought.

\ This article is part of my ongoing Gemini 3.0 challenge to push the boundaries of automated engineering.

\