When to use an edge worker
Run on the edge when you need low latency or privacy: frames never leave the site. Run on the cloud when the model needs more compute than the device has. A single workflow can span both sides.How it works
- One edge device → one worker container → one runtime → many worker modules. One worker container runs per edge device, not per twin. Workers can consume data from all twins in the environment at the same time.
- Edge Core names the container
cyberwave-worker-{env_uuid[:8]}and runs it from thecyberwaveos/edge-ml-workerimage. Edge Core manages the container lifecycle, so you don’t need to run it yourself. - Workers have access to the Zenoh data bus, cached model weights, and all environment twin data.
- The container mounts worker scripts and model weights from the host as read-only volumes.
- Each worker declares hooks (callbacks for sensor data) and model loading with the
cwclient:@cw.on_frame,cw.models.load,cw.publish_event. No imports needed.
Worker files live on the host in
{CONFIG_DIR}/workers/ (default ~/.cyberwave/workers/ on all platforms).
Run a model
- No-code (workflows)
- Python
When a workflow with a Camera Frame trigger and a connected Call Model node is activated in the UI, the backend generates a To raise alerts from detections, add a
wf_*.py worker module for that workflow.1
Activate a workflow
In the UI, activate a workflow with the chain Camera Frame → Call Model → an edge-compatible model.
2
Edge Core syncs it
Edge Core syncs on next boot, on
CYBERWAVE_WORKER_SYNC_INTERVAL_LOOPS expiry (default every ~5 minutes), or immediately when a sync_workflows MQTT command arrives on the twin’s command topic. That command is sent by cyberwave workflow sync, by POST /twins/{uuid}/sync-workflows, and — for run_on_edge workflows — automatically by the activate API itself. So flipping the UI toggle takes effect on the edge within seconds instead of up to one sync interval.3
The worker file appears
wf_<uuid8>.py appears in the workers directory. The file is written atomically. Content-identical files are left untouched to avoid spurious worker container restarts.4
The container restarts
The WorkerWatcher detects the new file and restarts the worker container.
5
The hook runs
The worker container loads the new module and activates the hook.
Scope of the pull: Edge Core only pulls
wf_*.py files for the twins the
operator selected at install time (the twin_uuids list in
~/.cyberwave/environment.json). Workflows targeting twins that are not in
that list stay off this edge even if those twins happen to share its
fingerprint in metadata — re-run cyberwave edge install to change the
selection.send_alert node. See Raising alerts from detections. To change the generated logic, eject it into a custom worker.Worker API
Hook decorators
Register callbacks for sensor streams. Hooks are passive at import time — the runtime activates them.
All callbacks receive
(sample_payload, ctx) where ctx is a HookContext with timestamp, channel, sensor_name, twin_uuid, and metadata.
Passing
sensor=None (or omitting it) subscribes to every sensor of that
type on the twin — the SDK constructs a frames/** (or depth/**, etc.)
wildcard key expression. ctx.sensor_name is populated from the observed
publish key so a single handler can disambiguate multi-sensor twins.
Pin sensor="<name>" (e.g. "color_camera") when you need to target one
specific sensor — the name must match what the twin asset declares.fps parameter on @cw.on_frame controls the frame sampling rate.
Model loading
cw.models.load() caches models, so it’s safe to call at module level.
Publishing events
cyberwave/twin/{uuid}/event via MQTT. The payload matches the backend mqtt_consumer.handle_business_event() schema.
Runtime entrypoint
Worker modules never callcw.run_edge_workers() themselves. The container entrypoint does:
Workflow-generated workers
Raising alerts from detections
call_model no longer publishes alerts on its own (the legacy emit_event config was removed). To raise alerts from a camera_frame → call_model chain, wire an explicit send_alert node downstream. Optional gating nodes preserve the previous emit_mode / cooldown semantics:
detection_event_gate— class filtering pluson_enter(new classes only) /on_change(count changes) modes.timed_condition(mode: debounce,cooldown_s: <seconds>) — minimum delay between consecutive fires, replacing the oldcooldown_seconds.
cw.publish_alert(...) only when the gate and timer agree:
send_alert whose immediate upstream is call_model defaults to force=True. The per-frame publish loop bypasses the backend’s content-hash dedupe, so two consecutive identical detections still raise distinct alerts. Set parameters.force to false on the send_alert node to opt back into the dedupe. When a gate or timed_condition sits between call_model and send_alert, the heuristic backs off and the long-standing force=False default applies (the gate already debounces).
A timed_condition placed downstream of call_model without a trailing send_alert is inert — the legacy implicit-alert path it used to gate is gone. The compiler attaches a warning to the resulting compilation so the silent-skip case is visible in cyberwave workflow sync preflight output. The worker still ships and runs inference, but nothing is published until you wire the send_alert.
See the emit_event migration table for the field-by-field mapping (including the force=True default).
Removing a workflow from the edge
Deactivating, soft-deleting, or flippingrun_on_edge off publishes a surgical remove_workflow_worker MQTT command to each affected twin command topic, naming the specific worker file(s) to unlink. Edge Core deletes the matching wf_*.py and immediately reconciles the worker container lifecycle. The workflow stops running on the device within seconds rather than waiting up to one full periodic interval (~5 minutes) plus the bulk-sync two-strikes cleanup. The same path is used for the cascade cases (workspace or environment deletion that removes the workflow). The periodic reconcile remains the correctness backstop if the MQTT publish is dropped.
Eject a generated worker
A generatedwf_*.py worker can be ejected into a custom worker when you need to customise the logic beyond what the workflow graph supports.
- The
wf_*.pyfile is deleted on the next edge sync (because the workflow was deactivated). - Your
my_detector.pyis untouched by edge sync — you own it. - Edge sync never writes to files that do not start with
wf_.
Generated worker format
For reference, here is what a generated worker looks like (withon_enter emit mode and cooldown):
cw is injected as a builtin, models are loaded at module level, and events are published with cw.publish_event.
Choose a model
Declare model requirements
Declare model dependencies incyberwave.yml inside the workers directory:
cw.models.load("...") calls in worker Python files. See Model cache for how weights are cached.
Pick the model format
Each catalog model declares an edge runtime that tells the worker how to load the checkpoint. The runtime selector lives in the model editor (/models → “Add Model” or “Edit”). It is also accepted as a typed edge_runtime field on POST /api/v1/mlmodels and PUT /api/v1/mlmodels/{uuid}.
The well-known runtimes mirror the loaders in the Cyberwave Python SDK’s cyberwave.models.runtimes registry:
Custom values are accepted via the editor’s “Other” entry. They are used today for framework-specific identifiers like
sam2, sam3, and depth_anything_v2 that don’t have an SDK loader yet but still need to round-trip through the catalog.
GET /api/v1/mlmodels/edge-runtimes returns the current well-known list (no auth required), so external tools can mirror the dropdown without hard-coding it.
Detection post-processing (NMS and caps)
Detection post-processing (NMS and caps)
ONNX YOLO postprocessing applies per-class non-max suppression with a default IoU threshold of
0.7. So swapping yolov8s.pt for yolov8s.onnx produces the same number of boxes per object instead of a cluster of overlapping anchors. Override per call with model.predict(frame, iou=0.5) (stricter) or iou=1.0 (raw output, no suppression).NMS-free detectors (YOLO26’s default one-to-one head, YOLOv10) emit [max_det, 6] = [x1, y1, x2, y2, conf, class_id]. The SDK’s ONNX runtime detects this layout automatically and parses it without the anchor-decoding step. The model’s one-to-one head is supposed to already be deduplicated, but some exports (open-vocabulary heads especially) can still emit many near-duplicate boxes for one object, so the same iou NMS also runs here as a safety net. End-to-end pose / segmentation exports are not decoded yet. Re-export those tasks with end2end=False until the e2e pose branch lands.Every detection result is also capped at max_detections_per_class (default 30) highest-confidence boxes per label, applied after NMS. This is a backstop for models whose suppression doesn’t fully collapse duplicates (open-vocabulary heads like YOLOE are the common case). Pass model.predict(frame, max_detections_per_class=None) to disable it. The Ultralytics runtime also defaults every call to end2end=False, so real NMS runs on the one-to-many head instead of trusting a checkpoint’s self-reported “already deduplicated” flag. Checkpoints with only a one-to-one head (fused .pt, TensorRT, some ONNX exports) fall back to end2end=True automatically.YOLO ONNX catalog
YOLO ONNX catalog
The public catalog ships ONNX twins for the most common YOLO entries. Cyberwave hosts the exported weights at
https://static.cyberwave.com/ml_models/{name}.onnx, so edge nodes can fetch them with no Ultralytics CDN dependency. They are roughly 2× faster on CPU than the .pt build:Pick
Edge Runtime: ONNX Runtime in the model editor (or metadata.edge_runtime = "onnxruntime" via the API) when registering a private fine-tune that you’ve exported via YOLO("…").export(format="onnx"). The SDK’s OnnxRuntime reads names and kpt_shape from the ONNX custom_metadata_map, so labelled detections and keypoints work out of the box.Segmentation, OBB, and classification ONNX exports are not yet supported by the SDK runtime. Use the .pt (ultralytics) variants for those tasks.YOLO Hailo catalog
YOLO Hailo catalog
For Hailo-accelerated edge nodes (Raspberry Pi 5 + AI HAT+ and the older Pi AI Kit), the catalog also ships pre-compiled YOLO HEFs straight from the Hailo Model Zoo. Each upstream YOLO checkpoint gets two sibling rows — one per Hailo architecture — because HEFs are hardware-locked:
Slugs use the
_h8 / _h8l suffix on purpose: cw.models.load("yolov8s_h8") is enough to route through the SDK’s hailo runtime, with no extra arguments. Pick the row that matches your edge target. A Hailo-8 HEF will refuse to run on a Hailo-8L (and vice versa).If you pick the wrong sibling, Edge Core catches it before the download starts. A Gate-3 preflight probes the connected accelerator with hailortcli fw-control identify and refuses to fetch a HEF whose metadata.hw_arch disagrees with the device, naming the correct sibling in the error message. The preflight is silent when hailortcli is not installed on the host. Install it via apt install hailo-all (or the matching HailoRT package) to enable the check.Edge speech-to-text
Edge speech-to-text
Seeded Whisper.cpp STT models can run from
Audio Track -> Call Model workflows on Raspberry Pi 4-class devices. The generated worker passes the audio chunk and seeded download_url into the local whisper_cpp runtime, so the first run downloads missing weights into the Cyberwave model cache. Downstream nodes can use text, transcribed_text, and segments.English GGML checkpoints: Tiny EN, Base EN, and Small EN (Q5_1). Multilingual checkpoints: Tiny Multilingual and Base Multilingual — hybrid deployment with edge_runtime: whisper_cpp on edge missions and whisper cloud-node fallback (openai/whisper-tiny / openai/whisper-base) on cloud missions. Use multilingual models when the spoken language is unknown or mixed.Hybrid Faster Whisper catalog entries (faster_whisper runtime) run on-device when the workflow mission executes on the edge. Cloud missions use the whisper cloud node with the same OpenAI model aliases (openai/whisper-tiny → tiny.en, etc.). Prefer Faster Whisper Tiny EN for real-time English streams. Use Whisper Tiny Multilingual Q5_1 for multilingual edge STT without CTranslate2.Model weights resolution
For each required model, Edge Core resolves weights in this order:- Local cache (intact). If
~/.cyberwave/models/{model_id}/...is present and its SHA-256 matches the manifest, it is used directly. - Cyberwave-hosted signed URL. If the catalog entry has a checkpoint mirror, Edge Core fetches a signed URL via
GET /api/v1/mlmodels/{uuid}/weightsand downloads from our private bucket. - Upstream weights URL. If no Cyberwave mirror exists, Edge Core falls back to the public
download_urlfrom the catalog (e.g. an official Ultralytics release). - Stale cache fallback. If every download attempt fails but the local file is intact, Edge Core returns the cached file with a warning. This keeps workers running across transient network failures and on permanently air-gapped sites.
~/.cyberwave/models/{model_id}/. Edge Core computes a SHA-256, infers the runtime from the file extension (.pt, .onnx, .engine/.trt, .tflite, .pth, .xml), and writes a sidecar metadata.json on the next worker start. To update a pre-staged model, overwrite the file in place. Edge Core re-stamps the manifest from disk on the next call (no re-download attempted). Pre-staged files are never auto-overwritten by catalog updates. To force a re-download from Cyberwave, evict the model directory (rm -rf ~/.cyberwave/models/{model_id}).
Container images and hardware
Edge Core pulls the worker image for you, in the background, socyberwave edge install stays fast and non-blocking. There is no need to wait for the image download during installation.
Release channels:
Image variants
The worker image is published in four variants on Docker Hub:
All four variants ship the same Python API. PyTorch/Ultralytics models pick the device automatically. ONNX models gain
CUDAExecutionProvider only on the -gpu variant. .hef files load through the hailo runtime only on the -hailo variant.
How Edge Core picks a variant
Edge Core detects the NVIDIA container runtime and passes--gpus all to the worker container when available. It selects the variant automatically based on host capabilities:
- Jetson host detected (
/etc/nv_tegra_releasepresent) → appends-jetsonand adds--gpus all. This wins over the-gpubranch: on Jetson the nvidia-container-runtime is present too, but the amd64-gpublob has the wronglibcuda.soABI (desktop/server CUDA vs Tegra CUDA). - NVIDIA container runtime detected (not Jetson) → appends
-gputo the configured worker image tag and adds--gpus all. /dev/hailo0present and no GPU runtime → appends-hailo, adds--device /dev/hailo0:/dev/hailo0:rwmand--group-add hailo(on HailoRT < 4.20 hosts), and setsCYBERWAVE_REQUIRED_DEVICES=/dev/hailo0so the image’s Gate-4 entrypoint fails fast if the passthrough is missing.- None → uses the CPU base image.
-jetson image isn’t published for your channel yet), Edge Core falls back to the CPU image and logs the demotion.
Jetson details
Jetson details
The
-jetson variant uses PyTorch/torchvision/torchaudio and onnxruntime-gpu wheels from the Jetson AI Lab devpi index (Orin sm_87 builds), not the amd64 -gpu variant’s index. The image base is ubuntu:24.04; NVIDIA has not yet published an l4t-jetpack image for JP7. nvidia-container-runtime injects the host’s CUDA driver at container start. The image itself bundles the matching CUDA 12.9 userspace runtime libraries (libcudart, libcublas, cuDNN), since the Jetson wheels link against system CUDA rather than bundling it. ONNX Runtime exposes CUDAExecutionProvider on Jetson, same as the -gpu variant.JetPack 6 hosts are not supported. JetPack 6’s CUDA driver predates what’s needed to run a CUDA 12.9 runtime, so only JetPack 7 hosts should pull this tag. Edge Core reads the L4T release from /etc/nv_tegra_release and starts a JetPack 6 board on the plain (CPU, multi-arch) tag instead, logging a warning. CYBERWAVE_JETSON_ALLOW_UNSUPPORTED_L4T=1 forces the -jetson tag anyway. This is decided when the worker container is created, so a board already running a -jetson worker keeps it across an Edge Core upgrade. Remove the container once (docker rm -f cyberwave-worker) to pick up the new selection.Hailo details
Hailo details
The
-hailo variant compiles HailoRT (libhailort + hailortcli + pyhailort) from the MIT-licensed upstream source at hailo-ai/hailort at a pinned tag. The LGPL-2.1 GStreamer plugin (hailonet) is left out of the build. The companion kernel driver (hailo-ai/hailort-drivers) is installed on the host (e.g. via apt install hailo-all on Raspberry Pi OS), not in the container. Its minor version must match the userspace lib baked into the image.Lifecycle
Edge Core starts the worker container only when at least one workflow is active for the connected twins (i.e. the latest sync produced one or morewf_*.py files in {config_dir}/workers/). When no active workflow exists, the cyberwaveos/edge-ml-worker image is not pulled at all.
Workflow activations and deactivations are picked up automatically:
- At startup: after the workflow sync step, the worker container is started if files exist. Otherwise startup logs
No active workflows for connected twins; worker container not startedand proceeds. - At runtime: every ~5 minutes the workers directory is re-synced. The worker container is started when files appear and stopped when files disappear. Both transitions are idempotent.
- Immediately on activate: when a
run_on_edgeworkflow is activated, the backend publishes async_workflowsMQTT command on each referenced twin’s command topic. Edge Core runs an immediate sync and lifecycle reconcile, so the newwf_*.pylands within seconds. - Immediately on remove (deactivate / soft-delete /
run_on_edgeflip off): the backend publishes aremove_workflow_workerMQTT command and Edge Core unlinks the file within seconds. See Removing a workflow from the edge.
cyberwave edge sync-workflows --twin-uuid <twin_uuid> (or cyberwave workflow sync <workflow_uuid>) triggers an immediate sync via MQTT, which reuses the same lifecycle path on the next reconcile.
Hot-reload on file changes
Edge Core monitors the workers directory every ~15 seconds. When.py files are added, removed, or modified, the worker container is automatically restarted with the updated set of workers.
A minimum cool-down of 10 seconds between successive automatic restarts prevents rapid churn when files are written incrementally.
Health monitoring
Edge Core continuously monitors the worker container:- Restart accounting: every restart is recorded with timestamp and reason.
- Circuit-breaker: after 5 restarts in 5 minutes, automatic restarts are suppressed until the window clears. Run
cyberwave worker healthto inspect the state. - Spontaneous exit detection: if the container exits without a deliberate restart, a warning is logged.
Configuration
Tune log verbosity
Worker containers and edge-driver containers have separate log-level knobs, so you can raise one toDEBUG without drowning in the other.
Edge Core auto-forwards any
CYBERWAVE_* env var it sees in its own process environment into each worker container at docker run time. So the same knob works whether you set it in the systemd unit, the CLI install env, or the shell. Workers print one INFO line at startup naming the resolved level and the variable that supplied it (e.g. Worker runtime starting with log level=INFO (source=default)), so you can verify the knob took effect without inspecting the container.
In steady state, per-node workflow trace lines (Workflow node started: <uuid>, Workflow node finished: <uuid>) log at DEBUG, not INFO. They fire 20–30×/s on frame-driven workers and would otherwise dominate the log. Errors (Workflow node failed) and per-execution boundaries (Workflow execution finished) stay visible at the default level.
The generated workflow logger is hierarchical (cyberwave.workflows.<workflow-uuid>), so you can also tune workflow verbosity per instance from inside a worker without touching the root logger:
Performance tuning
Model warm-up
The worker runtime automatically runs two dummy inferences on each loaded model at startup to eliminate cold-start latency (JIT compilation, memory allocation). Cold vs warm latency is logged. You can also warm up models explicitly:Frame resolution scaling
SetCYBERWAVE_WORKER_INPUT_RESOLUTION to downscale incoming frames before they reach your worker hooks. This reduces inference time on constrained devices without changing the camera driver’s publish resolution.
Shared memory transport
Zenoh shared-memory (SHM) transport offers zero-copy frame delivery between the camera driver and worker containers on the same host. Edge Core leavesZENOH_SHARED_MEMORY disabled by default. SHM between Docker containers requires them to share an IPC namespace via --ipc=host, which weakens container isolation and has historically been a source of instability in production.
To opt in, enable the flag on both the publisher and any same-host consumer. Give each container a shared IPC namespace (--ipc=host) and a raised locked-memory limit (memlock=-1). The default 8 MB cap is too small for a frame pool, and without it the transport silently falls back to copy.
ZENOH_SHARED_MEMORY=true once in its environment and it propagates the flag to the driver and worker containers. With the SDK directly, set it on each container (or pass ZenohBackend(shared_memory=True)). Zero-copy applies only to frame-sized payloads. Small messages (joint states, etc.) always copy. Optional publisher knobs:
If the pool can’t be created, publishing degrades to the copy path with a warning rather than failing. When it’s exhausted by a slow consumer, the
ZENOH_SHM_ON_EXHAUSTION policy decides between copying and dropping the frame. The pool is allocated per frame whether or not a subscriber can use zero-copy, so enable SHM only when a same-host, SHM-capable consumer is actually reading the stream.
Consuming the stream from your own process
The SHM path isn’t specific to the ML worker — any Zenoh peer on the same host can read a driver’s frames zero-copy. To consume from your own process:- Run it on the same host. If it’s containerized, launch it with
--ipc=host(or--ipc=container:<driver>) so it shares the IPC namespace. A process running directly on the host already qualifies. - Enable SHM in its Zenoh session:
ZENOH_SHARED_MEMORY=truevia the SDK, ortransport/shared_memory/enabled=trueon a raw Zenoh session. A consumer that leaves SHM off still receives every frame, just copied over loopback instead of zero-copy. - Subscribe to the driver’s channel. With the SDK, use
DataBus.subscribe(...)— it resolves the key for you.memlock=-1is only needed if your process also publishes SHM.
eclipse-zenoh) receives each frame as a copy. The zero-copy is the transport hop, so it still cuts latency and jitter but not the final ingest copy. A native C++/Rust Zenoh consumer can map the shared buffer and read it zero-copy end-to-end.
To measure hot-path performance on a device, use Edge Bench.
CLI reference
Worker commands
cyberwave worker list shows the origin of each worker:
Monitor workers
cyberwave worker monitor opens a live-updating terminal dashboard for the running worker container.
Requirements:
- Docker must be running on the host.
- For Zenoh throughput, hooks, and model metrics:
eclipse-zenohmust be installed (pip install eclipse-zenoh). - GPU metrics require NVIDIA drivers and
nvidia-smion Linux. macOS shows “N/A” for GPU.
Workflow commands
Thecyberwave workflow command group lets you manage workflows from the terminal:
--base-url / -u to override the API URL (e.g. http://192.168.10.101:8000). When a UUID is omitted, an interactive arrow-key selector is shown.
The sync command reads the workflow’s camera_frame trigger nodes to discover which twin(s) it targets. It then sends a sync_workflows MQTT command to each twin’s edge node, which triggers an immediate HTTP pull of the latest worker files.
Troubleshooting
@cw.on_frame hook never fires
Run cyberwave worker doctor first. It runs both static (“paperwork”) and runtime (“actual traffic”) checks.
Static checks surface the most common config-level failures:
cyberwave-edge-corenot installed. Worker containers are managed by edge-core. Install withcyberwave edge install.- Worker files not world-readable. The container runs as a non-root user (UID 1001) and cannot read mode
0600files.cyberwave worker addchmods files to0644automatically. Files installed manually may needchmod 0644 ~/.cyberwave/workers/*.py. - No co-located driver container. Workers only receive frames from drivers on the same Zenoh session. Check
docker ps --filter name=cyberwave-driver-on the edge host. - Env drift between driver and worker. Mismatched
CYBERWAVE_ENVIRONMENT,ZENOH_CONNECT,CYBERWAVE_DATA_BACKEND, orZENOH_SHARED_MEMORYproduces a container that looks healthy but never publishes on the key the worker subscribes to. The doctor compares these across the running driver and worker containers, and flags legacy env-var spellings (e.g.ZENOH_SHM_ENABLED) that are silently ignored.
zenoh-liveness— counts keys seen on the bus during the probe. Zero traffic means either no publisher is running or the doctor can’t reach the router.keyexpr-alignment— for every@cw.on_*(<twin>)hook the scanner can resolve statically, asserts at least one matching key is being put on the bus. Diagnoses three common failure modes:- Sensor mismatch — hook listens on
sensor="default"but the driver publishes onsensor="color_camera"(or vice-versa). - Wrong twin — the channel is flowing, but under a different twin UUID than the hook expects.
- No publisher — nothing on the bus looks anything like the hook’s expected key.
- Sensor mismatch — hook listens on
keyexpr-scoping— flags publishers that put to non-canonical keys likeframes/color_camera(nocw/<twin>/...prefix). Twin-scoped hooks silently drop these. The checker accepts only the canonical shapecw/<twin-uuid>/data/<channel>[/<sensor>].
--no-runtime (pure paperwork) or extend the window with --window 6 when traffic is bursty. The probe requires eclipse-zenoh on the host (pip install --user eclipse-zenoh). When it’s missing, the runtime section degrades to an info message rather than failing.
A healthy edge node shows
keyexpr-alignment ok and ~25 fps on cw/<twin-uuid>/data/frames/<sensor> in the zenoh-liveness top-keys list, alongside a ticking cw/_monitor/worker_stats key.Manual fallback: inspect the bus with eclipse-zenoh
If the doctor can’t reach the router (remote edge, unusual network), the same sanity check is one script away:cw/<twin-uuid>/data/frames/<sensor>. If the key list is empty or uses a different twin/sensor than your @cw.on_frame(...) call, fix the publisher. The worker will never see those messages otherwise.
Worker keeps restarting, then stops
The circuit-breaker suppresses automatic restarts after 5 restarts in 5 minutes. Runcyberwave worker health to see the restart history and reasons, then check cyberwave worker logs.
Next steps
Model cache
How Edge Core caches model weights before a worker starts.
Edge Bench
Measure Zenoh SDK hot-path performance on your device.
Annotate and anonymize nodes
Anonymize or annotate camera frames from a workflow, no Python needed.
Frame substitution
Put a worker-processed frame into the camera’s WebRTC stream.
Camera detection overlays
Draw YOLO boxes from a worker onto the camera stream.
Multi-camera detection routing
Route detections to the right twin when one worker handles many cameras.
Record and replay
Capture live edge data and replay it for debugging.
Security pipeline
Two cameras, one worker, no raw video off the edge.