Documentation/Verify and operate

Verify and operate

Run AI image and video watermarking without a GPU

The qualified Ariadne Mark 0.7.3a4 image/video workflow runs on Linux x86-64 CPU with Python 3.12. You can evaluate it on an ordinary backend worker; a GPU is not required for the tested workflow. Provision the runtime and models first through the release quickstart.

What hardware was actually tested?

The current complete-SDK measurements used an AWS EC2 m6a.large with two vCPUs and 8 GiB host RAM. Each benchmark container was limited to two CPUs and 4 GiB memory. Those are test conditions, not a minimum specification or a guarantee of capacity for any input.

Check image dimensions, video duration/FPS/codec, concurrency and service overhead for your own workload. The measurement page reports kernel cgroup memory peaks reset for each operation, including charged cache. These differ from process RSS, the container limit and total host-RAM requirements. The smaller hosted image playground is a separate application and does not establish memory requirements for your full deployment kit.

Keep models resident between jobs

  1. Install the pinned runtime and models during setup.
  2. Start a bounded worker process and construct its SDK after startup.
  3. Reuse that SDK for jobs instead of rebuilding the models on each request.
  4. Close it during shutdown. Create a new SDK inside each process after a fork; do not inherit a live model or video worker across the fork.

The Python example provides a reusable export function. A Node.js or Next.js application can keep its existing queue and delegate work to that Python worker. Calling the CLI for each file is a simple boundary, but can pay a new-process startup cost.

Choose threads, workers and video profiles separately

The documented image example uses two image threads. Control product-level concurrency through your queue rather than assuming that more threads always produce proportionate throughput. Separate processes load their own models; budget additional memory before adding workers.

Economy5s and Economy2s reduce selected-frame inference. Resilient computes a fresh signal on every frame. All profiles still decode and encode the full video, so sparse marking does not remove the media-processing cost. Use the profile guide or the scenario-based mode selector with the measured timings and cost calculation.

What should happen if a worker crashes?

Publish the returned final file only after a successful export. Keep receipts and the registry on persistent storage. Use unique output paths and your own job idempotency rules; the SDK will not overwrite an existing output.

An export failure should remain a failed job. Do not make unmarked input the automatic publication fallback. Reconcile job state and staging files before retrying, including cases where a batch completed earlier jobs before a later failure. The stock-product example illustrates queue and retry boundaries.

Size the exporter and verifier separately

Your export queue and public verifier are different workloads. A busy export service does not mean verification needs the same number of workers, and an early positive read is not a bound on the cost of searching an unmarked video.

The 0.7.3a4 reference verifier has one inference slot, four upload slots and no queue. Busy requests can return HTTP 429. The application upload ceiling is 512 MiB; the generated TLS edge defaults to 128 MiB. Align limits before exposing the service. See the exact reference limits.

For a first deployment:

  1. Keep export jobs behind your own bounded queue and publish only completed outputs.
  2. Measure export CPU/memory separately from positive, negative and incomplete verification scans.
  3. Test two near-simultaneous verification requests and implement a useful busy/retry response; do not assume an internal queue exists.
  4. Retain one controlled writer path for the registry and read-only verifier access. Qualify database behavior, backups and resource use before increasing concurrency.

Adding verifier processes or replicas is not a documented automatic scaling feature. Processes have their own model memory, and a larger deployment needs a tested routing, storage and capacity design. Do not multiply the single-file benchmark by a worker count and call it measured throughput.

Queue, retry and backup recipe · Deploy SDK + verifier + registry · Supported formats and platforms · Runtime troubleshooting

Separate export and verification

One SDK shares one video worker across its profiles and verification. An entire export/scan holds that worker lock;waiting for it is outside the scan budget. Run a public verifier in its own process with a separate SDK,as the deployment kit does. See worker ownership.