Active inference is a novel brain theory based on the free energy principle, stating that every organism, in order to stay alive, minimizes a certain free energy. This theory is being translated into robot control, hoping to mimic the capabilities of the brain. Research in this field of robotics is still quite young, and active inference has yet to mature into a reliable control theory. Implementations of active inference are scarce, and hierarchical implementations, containing multiple layers of active inference, are almost non-existent. This work presents the first implementation of hierarchical active inference performing online control on a robot in continuous state-space. The robot in question is a skid-steering mobile robot, on which two different active inference controllers are implemented and compared. The first controller is a non-hierarchical active inference controller giving wheel speed commands to the default PID controller of the robot manufacturer based on desired body velocities. The second controller is a novel implementation of a hierarchical active inference controller, that besides the function of the first controller, also replaces the low-level PID control with active inference, resulting in two-layers of active inference ultimately taking desired body velocities as inputs and translating it into open loop voltage commands for the motors. Both controllers are tuned to give roughly the same step responses in order to get a clearer view on the differences between non-hierarchical and hierarchical active inference. During the tuning process of the hierarchical controller, it became clear that no amount of tuning could get the (causal) states to convergence sufficiently fast. This problem was identified to be caused by the message passing in between the layers of active inference, where the prediction error from below negatively impacts convergence. This impact scales together with the tuning parameters, and therefore is not easily fixed by tuning alone. A potential solution is given in the form a an extra parameter in front of the upwards prediction error, giving the ability the independently tune the impact of this error on the behaviour of the system. This solution is used to fully tune the hierarchical controller, after which the performance is compared to the non-hierarchical controller, using a series of experiments. A total of 8 experiments are done where both controllers are tested performing two driving actions in two situations, namely cornering and pivoting on the ground and with the wheels suspended. The non-hierachical controller, as a baseline, performed satisfactory, but the hierarchical controller does not run smoothly on the ground, potentially struggling with the stick-slip of the wheel-ground interactions. From this it seems that using active inference for the low-level, as compared to something like PID, is less suitable. However, that conclusion is too premature for this work as the available encoder feedback frequency for the active inference is way lower than what the MCU-level PID has access to, making the comparison less fair. The main contribution of this work lies in the insight in the implementation structure of hierachical active inference for continuous state-space control, which can be further built upon, using the lessons learned during implementation.