Run Mirage Locally: OCR and Object Detection from One Image

Cactus Compute’s Mirage can inspect a local image and return text, object locations and structured fields. The developer's roughly 22 MB two-bit model is small enough to try without downloading a multi-gigabyte vision checkpoint. Start with a device label or a clean screenshot and compare the returned fields against the original image before automating a workflow.

The official release describes a 51.3 million parameter vision model, a local browser demo and an installable runtime. It reports 74 ms on one Samsung Galaxy S26 NPU configuration and 107 ms on that phone's CPU. Those timings describe that setup. Use your own device and inputs to check performance and accuracy.

What tasks fit this model?

Mirage can describe scenes, detect objects, read text, return masks and answer constrained questions. For an inventory task, you might ask it to identify a label, extract the text region and return a limited set of fields. For photos, you might use object locations as hints for a human reviewer. A structured answer is useful when it preserves a link back to the image evidence.

The developer lists seven languages for image descriptions. Do not assume support for every OCR script from that list. The actual text reader may miss an accent, confuse similar digits, or omit a small region. Cactus itself shows an imperfect OCR result in the release demo. The model card links runtime requirements and input examples.

How do you run the first local example?

Try the browser sandbox linked by Cactus with a non-sensitive test image. Then use the Python package on a platform supported by the Cactus runtime. Use a fresh environment and an image you control.

python -m venv .venv
source .venv/bin/activate
python -m pip install -U cactus-compute

The package's published example is:

import cactus

model = cactus.Mirage()
print(model.describe("photo.png"))

On first use, the package can download and cache the engine and model. Time that setup separately from inference. To confirm a later offline workflow, complete the initial installation, then test against a local file with networking disabled in an isolated environment. Check the runtime version and cache behavior rather than inferring them from the package name.

How should you build a small accuracy test?

Take three images of the same label: one evenly lit and straight, one rotated or reflective, and one with another label nearby. Keep a reference transcription. Compare exact characters and field associations, not only whether the output contains a plausible string. For object detection, inspect the boxes. A correct label attached to the wrong object can break a downstream inventory record.

Test a blank image, an image with no relevant field, and an unreadable crop. A usable extraction flow needs an explicit unknown or empty state. If the next step changes an inventory record, treat a missing or uncertain field as a review queue entry instead of guessing.

How much memory and latency should you expect?

The advertised 22 MB refers to the two-bit model representation. Runtime memory includes the inference engine, decoded input, intermediate tensors and application overhead. Image dimensions can affect preprocessing and memory pressure even if the model file stays the same. Track peak process memory along with model size when deciding what can run beside your other services.

Measure cold start, warm inference and end-to-end latency including image decode and postprocessing. A phone NPU benchmark cannot answer how long a NAS or low-power x86 CPU will take. Confirm support for your operating system and device in the runtime listing, then measure with the same images and code you plan to ship.

How do you keep the output useful and the input private?

Separate recognition from action. Store fields with a reference to the source crop and a validation state. Apply deterministic checks where possible: expected serial length, allowed characters, date parse, or quantity range. Show the crop beside the proposed field when a reviewer needs to correct it. This preserves a path back to the actual evidence.

A local model endpoint can reduce the need to transfer source images, but browser code, telemetry, cache behavior and other components still deserve a check. A model with visual reasoning can interpret text in the image as content. Do not let that text become an instruction to a shell or file operation. See the guide to keeping source data out of AI requests.

Where does a home server fit?

Keep original files in a scoped library and send only the image required for each task to the inference process. Put outputs into a separate folder or database for review. On a shared server, run a small batch first and check whether recognition jobs interfere with backups, file indexing or other users. The private-file compute and storage comparison and backup isolation guide explain the roles those services can play.

FAQ

Does the first run work entirely offline?

The package can fetch the engine and weights on first use. Verify offline behavior after installing and caching the required files.

Is 22 MB the memory usage?

It describes the advertised compressed model, while total process memory includes the runtime and image buffers.

Can Mirage read all receipts and labels?

Test the languages, lighting, fonts and layouts you actually see. Small or reflective text can produce wrong or incomplete output.

Can I skip manual review?

Use review for outputs that change records or trigger actions, especially when fields are uncertain or cannot be validated.

Can I use the phone benchmark to choose a home server?

Use it as an example for the tested phone. Benchmark the intended hardware and runtime with your actual images.

Conclusion

Mirage makes a small local OCR and image-understanding experiment easy to start. Install the supported runtime, test exact fields on a handful of challenging images and preserve a review path. Expand to larger batches only after the measurements and error handling are good enough for the job.