You can only access the RT cores implicitly through the three ray tracing APIs: OptiX, DXR, and Vulkan Raytracing extensions.
There is no way to program the RT cores directly because they have changed with every GPU generation and exposing their instructions would have limited these advancements.
The DXR and Vulkan API have two levels of ray tracing functionality, one using the full pipeline model like OptiX and one using explicit ray queries. That’s as low-level as it gets.
Links to the respective extensions for Vulkan in this post: https://forums.developer.nvidia.com/t/what-are-the-advantages-and-differences-between-optix-7-and-vulkan-raytracing-api/220360
There are different approaches to a renderer implementation possible as well. Some use the ray tracing APIs (and thereby the RT cores on RTX boards) only for the BVH traversal and ray-primitive intersection in a ray wavefront approach but do all ray generation and shading calculations in native CUDA kernels between the launches for performance and algorithmic freedom, but that requires intricate asynchronous programming and optimal memory accesses.
On the other hand, the OptiX SDK 8.0.0 release just added support for Shader Execution Reordering for Ada Lovelace GPUs which can greatly improve performance in renderers with a standard ray tracing pipeline with only little changes.
There shouldn’t be a problem running CPU and GPU calculations in parallel.
But if you’re mixing different ray tracing implementations, you will hardly be able to generate the exact same images. Means it’s not possible to get your CPU and GPU images pixel exact simply due to the different intersection programs and that could become visible when rendering in tiles, and especially when rendering animations.
Hybrid methods are either not done in tiles but maybe sub-frames of a progressive Monte Carlo algorithm, or usually just as full CPU fallback when there is no suitable GPU hardware available.
Note that the BVH traversal and ray-triangle intersection performance of dedicated hardware implementations will surpass CPU implementations by orders of magnitude.
If your intention is to learn how to do that, go for it. That is a very interesting topic and definitely worth learning, especially if you plan to work on this professionally. But if your intention is to implement an own renderer, learning how to use existing APIs most optimally would provide much quicker results.
Don’t underestimate the amount of developer years which have gone into implementing each of these ray tracing APIs and the underlying functionality. Just read through the OptiX Programming Guide and think about how you would implement the described features yourself.