From weeks to days: how agentic AI certifies every camera Fizyr OS supports

By Fizyr Product Manager Salah Alshaal

‍
Hardware agnostic vision is a claim that must be earned
Integrators choose their own cameras. They choose based on price, lead time, ingress rating, the vendor they already have a service contract with, and the space left in the cell.

Fizyr OS must perform. Being flexible carries an engineering bill. 

Vision performance depends on what the sensor delivers under working conditions, and datasheets do not tell the full picture. Take for example a camera that has a good-quality point cloud; moving the camera 40 cm higher on the factory floor can reduce its performance on polybags or taped or glossy items, or occlusion becomes an issue.

That's why at Fizyr we ensure every camera we support goes through a continuous certification before it reaches a customer site and stays in test afterwards.


What certification measures:

• Integration: Driver behavior, trigger and sync timing, frame latency, error recovery, and clean data flow into Fizyr OS. This is where most new hardware fails first, and where failures are cheapest to fix.
• Mounting geometry: Industrial vision focused topics like the field of view at a working distance, coverage across the top layer of a pallet, occlusion at the edges, and how detection quality holds up as the stack comes down and the camera sees deeper into the container.
• Point cloud quality: Density, noise floor, edge fidelity, and missing returns on the surfaces that cause trouble in practice: dark, reflective, transparent, and wrapped. We score against reference captures rather than vendor specifications.
• Industrial ruggedness and robustness: Long-run drift, vibration on the frame, dust, duty cycles at production rate, cable strain, and recovery after a power interruption. Simply verifying the performance within 10 minutes doesn't mean the camera is ready to perform for an industrial shift.

Together, these tests certify the hardware agnostic architecture itself. Every sensor added to the supported list is evidence that the architecture holds.

‍
An agentic lab, running on local models
The philosophy of Fizyr centers around the capability of local AI being essential at the heart of industrial products. And that's why the certification system was built around local agents.

The flow starts with our engineers defining the camera test targets, and agents plan the test matrix, drive the capture rig, run the workloads through Fizyr OS, score the output, diff results against stored baselines, write the report, and raise issues on what failed. Overnight runs are normal and daily check-ins become part of the quality culture.

The models run locally, on our own hardware, in our own lab. Three reasons for that choice:

• Data stays in the building: Certification runs on customer-representative product data, often under NDA. It does not leave our infrastructure.
• Volume is the point: Certification means thousands of captures, full-resolution images, and point clouds. Local inference keeps cost predictable and throughput high.
• The lab keeps working: No dependency on an external endpoint's availability, rate limits, or version changes mid-run.

MCP as the interface between agents and the lab
Our camera testing hardware is exposed as an MCP server: camera control, the motion, lighting and mounting rig, the dataset store, the Fizyr OS benchmark runner, the scoring stack, and reporting. Agents reach all of it through one protocol.

The practical payoff is in supporting new sensors; engineering must build a thin MCP layer on top of the camera's API, once that's complete, the test logic, scoring and reporting can stay the same. The certification pipeline grows sideways instead of being rebuilt for each vendor.

The same tools are available to our engineers directly. Anyone on the team can pull a capture, rerun a scoring job, or query historical results with the tooling the agents use.

Loop engineering keeps the production fleet honest
Certification has a shelf life and recertification is required in various scenarios. For example:

1. Fizyr OS ships new releases
2. Vision intelligence models updates
3. Vendors push new firmware, or camera APIs

Loop engineering closes the recertification effort gap. Every certified camera stays in the test loop for as long as it is in the production fleet: the suite reruns against stored datasets and against the physical rigs, and regressions surface as a diff against the certified baseline. Problems get caught before a release reaches a running cell.

‍
What partners get out of it
Faster answers, justified by data.

When an integrator asks whether a specific uncertified camera will work for a specific cell, at a specific height, on a specific product mix, we can answer in days with data rather than with an educated guess. Known limits get documented up front, so hardware decisions happen in the design phase instead of during commissioning.

‍
Why we build our own tooling
Fizyr sells ultra-fast and performant vision software. The engineering standard we apply to Fizyr OS is the standard we apply to the systems that build and validate it. Agentic AI, local models, and MCP are in production inside our own engineering workflow.

‍

‍

‍