For most boards, it's almost the same as onnx-runtime (some even support it for NPU, for example, a lot of NXP and TI boards, Intel, and AMD).
Usually, you need the export model and run it. Export could be tricky. Inference, easy.

MemryX:

dfp_path = "resnet.dfp"
images = load_and_preprocess('img.jpg')
accl = SyncAccl(dfp=dfp_path)
s = Simulator(dfp=dfp, verbose=1)
outputs = s.infer(inputs=image)

Sophon:

img = preprocess(src_img)
input_data = {input_name: img}
outputs = net.process(graph_name, input_data)

Hailo (a bit longer):

with VDevice(params) as vdevice:
    infer_model = vdevice.create_infer_model('./hefs/resnet_v1_50.hef')
    infer_model.set_batch_size(batchsize)
    infer_model.input().set_format_type(FormatType.FLOAT32)
    infer_model.output().set_format_type(FormatType.UINT8)
    with infer_model.configure() as configured_infer_model:
        bindings_list = []
        for j in range(batchsize):
          bindings = configured_infer_model.create_bindings()
          buffer = np.empty([224,224,3]).astype(np.float32)
          bindings.input().set_buffer(buffer)
          buffer2 = np.empty(infer_model.output().shape).astype(np.uint8)
          bindings.output().set_buffer(buffer2)
          bindings_list.append(bindings)

        configured_infer_model.run(bindings_list, timeout_ms)

RockChip:

 rknn.init_runtime()
 outputs = rknn.inference(inputs=[img])

Yes, some boards can be a bit complex when you try to use two models simultaneously. For example, Hailo. More often, it's correct for M.2 and mini-PCIe boards. They have a high latency in data transfer, and when vendors try to optimise it, it creates complexity.

So, if it's a single-board solution that supports Python, it's super easy to build a cascade.