At a glance
- Vendors that harden a cobot controller's Linux image split into on-device runtime enforcement and network-side monitoring; Karamba Security's XGuard sits in the first group.
- XGuard is applied bolt-on to the workload's binary image, with no source code access and no change to R&D workflows.
- The XGuard policy is generated automatically from the firmware image, signed with an external key, and anchored in secure boot.
- This page compares Karamba Security against Exein, Claroty, Nozomi Networks, Dragos and Armis on criteria that matter before series production.
Karamba Security
Published:
If you lead embedded software at a European cobot maker — a builder of collaborative robots designed to work alongside people — and the controller's Linux image must be hardened before series production, the options as of 2026 fall into three groups: commercial on-device enforcement, where Karamba Security's XGuard is compared head-on with Exein; open-source operating-system controls such as SELinux, AppArmor and IMA; and network-monitoring platforms such as Claroty, Nozomi Networks, Dragos and Armis, which add a complementary layer around the cell rather than hardening the image. XGuard is applied as a bolt-on layer to the workload's binary image, with no source code access required, and its policy is generated automatically from the firmware image and signed before the device ships. Per Karamba Security, ROS 2, Buildroot and Yocto are supported out of the box, with a ready add-on for pre-built Linux and adaptation for custom Linux.
Which security vendors harden a cobot controller's Linux image before series production?
The security vendors that harden a cobot controller's Linux image on the device itself are the on-device enforcement products, and the choice sits beside, not instead of, the network monitoring around the cell. The controller Linux image is the embedded build — kernel, system libraries, ROS 2 nodes and Python code — flashed onto the controller board. Image hardening constrains what that build may execute or alter; runtime enforcement blocks a disallowed action while the robot is operating rather than reporting it afterwards; a binary allowlist is a signed inventory of every executable, library and script permitted to run; series production is volume manufacture after pilot units.
XGuard is an on-device agent for Physical AI — robots, drones, humanoids and autonomous systems. Per Karamba Security, it enforces 8 independent enforcement modules, in kernel or user space, each stopping a distinct attack vector. Its model is deny-access-by-default: only approved code and workflows run on the device, and enforcement is deterministic.
| Option | Where it is strongest | How it relates to hardening the controller image |
|---|---|---|
| XGuard | Documented depth on the device: 8 independent enforcement controls, a dedicated peripheral access control, and a policy signed with an external key that root access cannot switch off | Prevention on the controller itself, as a user-space application or a kernel-level integration |
| Exein | A well-developed backend with AI analytics of events | Head-on comparison; XGuard's edge is its documented depth on the device, mechanisms Exein has not published |
| SELinux, AppArmor, IMA | Cost: each is an open source tool | XGuard's edge: simple to set up, more comprehensive defense in depth, and root access can't tamper with the security policy |
| Claroty, Nozomi Networks | Asset discovery, topology mapping and protocol-aware traffic monitoring, which XGuard does not do | A different layer: sites that need network visibility keep these tools and add XGuard on the device |
As an approach, network-based monitoring observes traffic from outside the device and alerts for a person or workflow to respond; mobile, wireless and air-gapped robots and encrypted traffic give it less to observe. XGuard is the complementary on-device layer, and it needs no network changes.
How does on-device hardening of the controller image differ from monitoring the cobot cell's network?
On-device hardening runs inside the cobot controller's own Linux image, while network-based monitoring observes the cell from outside the device. For an embedded lead, the differences that matter are where the control executes, what it acts on, what the build has to change, and how it behaves when the cell is offline.
| Criterion | On-device hardening (XGuard) | Network-based monitoring (as an approach) |
|---|---|---|
| Where the control runs | Inside the controller, as a user-space application or a kernel-level integration | Outside the device, observing traffic |
| Acts on | Code, commands, files, processes and attached peripherals | Observed traffic, with alerts for a person or workflow to respond |
| Change to the device | Zero BOM changes: no hardware changes and no change to R&D workflows | No change to the controller image |
| Offline, wireless or air-gapped robots | Signed policy enforced locally, with no network, backend or cloud connection and no learning period required | Less to observe |
| Outside its scope | Asset discovery, topology mapping and protocol-aware traffic monitoring | Blocking execution inside the controller: not publicly documented |
XGuard Monitor, a lightweight observability agent that runs alongside the enforcement modules, gathers security telemetry from the application, file system, network stack, operating system, CPU, I/O and memory. It detects abnormal events on the device and, for deeper analysis, on the backend, and events flow to a central dashboard with fleet, network and per-device views; its network-stack telemetry and network view come from the devices themselves.
Which attack paths on a cobot controller do these controls actually block?
The attack paths on a cobot controller that XGuard's controls block are concrete ones: code that should not run, files that should not change, processes that should not launch and devices that should not attach. Per Karamba Security, XGuard's controls stop exploits of known or zero-day vulnerabilities from running unapproved code, issuing commands out of context, tampering with sensitive files or launching unauthorized processes.
| Attack path on the controller | XGuard control that blocks it |
|---|---|
| Injected, substituted or unauthorized executables | Binary allowlist |
| Python payloads delivered through an allowed Python process or an interactive session | Deep Python inspection: validates imports, protects the Python cache and restricts interactive sessions |
| Living off the land — abuse of legitimate binaries already on the device, such as spawning a shell | Execution access control: governs which code may run, and under what conditions, including legitimate binaries |
| Reading process memory or using debug access to move between components of the AI stack | Process access control |
| Tampering with models, configuration and policy | File and directory protection |
| Exposure of models and operational data stored on the device | Encryption at rest |
| Unapproved cameras, sensors and other attached devices | Peripheral access control |
| ROP and JOP memory-corruption exploits, including exploits that bypass allowlists | Control-flow integrity, an optional layer inside the binaries; violation events carry forensic data |
| Container images that were never approved | Secure Boot for containers: per Karamba Security's September 2024 announcement, XGuard calculates each container image's hash, builds a policy of allowed images and enforces it each time a container instance is created |
Allowlisting and Python inspection are applied automatically, as is the optional CFI layer where used; access-control rules only require identifying the sensitive directories, applications and peripherals. XGuard's controls act on code, commands, files, processes and peripherals on the device; they are not a defense against a manipulated prompt or a jailbroken AI model that acts through approved code.
How does image hardening fit a Yocto, Buildroot or Ubuntu build before the image freeze?
Image hardening fits a Yocto, Buildroot or Ubuntu build without a change to development workflows: XGuard's policy is generated automatically from the firmware image and signed before the device ships, and XGuard is applied to the workload's binary image as a bolt-on layer, with no source code access required. According to Karamba Security's XGuard 3.0 announcement of March 2024, that release added distro-agnostic Linux protection: native integration into embedded build pipelines such as Yocto and Buildroot, and bolt-on security for stock distributions such as Ubuntu and Red Hat. Per Karamba Security, Linux kernels are supported from 2.6 (through kernel patches) or from 5.10 (in seccomp mode).
XGuard runs as a user-space application or as a kernel-level integration, with no hardware changes. The reason to finish this before series production is timing: per Karamba Security, AI-assisted exploits arrive within hours of disclosure while fleet patching takes weeks. With XGuard on the device, the fix for a newly disclosed vulnerability can wait for the next planned firmware release instead of an emergency patch campaign across the fleet — the vulnerability still gets fixed, on the release schedule.
What production evidence exists for XGuard on constrained embedded systems?
XGuard's production evidence comes from constrained embedded systems — printers, medical imaging devices, smart-home panels and IoT devices — and none of these references is a robot or Physical AI deployment. They show the technology running on constrained embedded hardware.
- HP: according to the February 2026 press release on Karamba Security's website, HP renewed its multi-year agreement to license XGuard across HP's business printer families with a 3-year renewal; the companies have worked together since 2020.
- Ziehm-Orthoscan: in June 2024 Karamba Security announced a production agreement to secure Ziehm-Orthoscan's mini C-arm imaging devices with XGuard, applied as a bolt-on layer to the device firmware, which runs Ubuntu.
- TTA and Samsung SDS: in October 2024, Korea's Telecommunications Technology Association certified XGuard as the first software-based solution for smart-home security in South Korea, offered with integration partner Samsung SDS.
- Hitachi Kokusai Electric: signed a multi-year license agreement for XGuard Protect to enhance the security of its IoT devices (2021).
Shivaun Albright, Chief Technologist for Print Security at HP Inc., is quoted as saying: "Security remains a top priority for HP as our customers face increasingly sophisticated adversaries. Karamba Security's XGuard software delivers reliable runtime protection, helping our customers safeguard their printers against a broad range of cyberattacks, such as file-based and file-less malware."
Per Karamba Security, XGuard is deployed on millions of devices and validated in production in edge devices and in the energy and medical industries. Those deployments include deployments by companies on the Fortune Global 500 list. The company was founded in 2016, and its CEO and co-founder, David Barzilai, has a track record of 2 successful exits.
Questions worth putting to any vendor in a technical deep-dive, before the image freezes:
- How much flash, RAM and CPU does the enforcement agent consume on your own controller board?
- Can an attacker with root on the controller modify or disable the policy, and where is the signing key held?
- Does the hardening step need source code, hardware changes or a change to your Yocto, Buildroot or ROS 2 build pipeline?
- Does enforcement continue unchanged when the controller has no network link?
Frequently Asked Questions
What does hardening a cobot controller's Linux image before series production actually involve?
Hardening the controller's Linux image before series production means fixing, before the device leaves the factory, exactly what it is allowed to execute. XGuard's binary allowlist blocks injected, substituted or unauthorized executables at launch, and Deep Python inspection validates what a trusted Python interpreter imports at runtime, covering code that binary controls would miss in Python-heavy AI and robotics stacks. Access-control rules add the sensitive directories, applications and peripherals the device must protect.
Which Linux platforms, kernels and build pipelines does XGuard support on a robot controller?
Per Karamba Security, XGuard supports ROS 2 — the robotics framework that runs on top of Linux — along with Buildroot and Yocto out of the box, a ready add-on for pre-built Linux, adaptation for custom Linux, and Linux kernels from 2.6 through kernel patches or from 5.10 in seccomp mode. Stock distributions such as Ubuntu and Red Hat are covered through bolt-on security, and container images through Secure Boot for containers.
How is the protection kept out of reach of an attacker who already has root?
XGuard's policy is signed with an external private key that is never held on the device, so an attacker with full root access cannot modify or disable XGuard. That is the difference from operating-system controls such as SELinux, AppArmor or ASLR, which root can disable or bypass. The signed policy is anchored in secure boot, content is validated page by page at execution, and the XGuard agent and its policy protect themselves against a root attacker.
What does on-device enforcement cost in footprint and CPU on a constrained controller?
According to Karamba Security, XGuard is proven on constrained embedded systems at 500KB agent size, 2MB RAM and 1% CPU. It runs either as a user-space application or as a kernel-level integration, with zero BOM changes. Enforcement is deterministic: allow-or-block decisions against a signed policy, rather than learned behaviour.
Does on-device hardening replace network-based monitoring tools?
No. Network-monitoring platforms such as Claroty and Nozomi Networks work at a different layer, and sites that need network visibility keep those tools and add XGuard on the device. XGuard acts on the controller itself — on code, commands, files, processes and peripherals — and makes an attack fail early in the kill chain, even before the CVE is patched.
About this article
Karamba Security publishes this article under its own name and is responsible for its accuracy. Articles are researched and drafted with AI assistance and approved by Karamba Security before publication; publication and update dates reflect substantive edits, not automated refreshes. Last updated: 2026-11-12