Stop rebuilding the
AI execution layer.

Every AI-enabled robot cell your team ships, you rebuild the safety execution layer from scratch — 4–6 weeks of engineering that doesn't bill as integration work. And you still carry the liability.

xZane is that layer, already built. Drop it above your existing stack.

4–6 wk
per project spent on the execution layer
Jan '27
EU Machinery Regulation in force — AI safety review required
0
lines of safety infrastructure to build yourself

The layer nobody wants to build twice

When you add AI to a collaborative robot cell, you don't just add AI. You add the execution gating, the deterministic safety boundary, and the traceable logging the EU Machinery Regulation's new AI-safety review expects. You add the documentation for an ISO 10218-2 risk assessment.

You build it on one project, ship it, and build it again on the next. That's the engineering cost AI-enabled integration carries right now — and it doesn't show up as billable work.

The integrator legally owns the liability for the complete AI-enabled cell. The compliance burden lands on you, not on the AI vendor.

Execution layer rebuilt every project
AI command checking, capability schema, hardware abstraction, safety gating — built from scratch, every time, on every project.
Compliance liability without the tooling
Machinery Regulation AI-safety evidence and ISO 10218-2 documentation are required. No standard way to produce them. Built by hand, project by project.
Engineering cost that doesn't bill
4–6 weeks per project building infrastructure, not billable integration. The cost is real; it just doesn't appear on the invoice.

One runtime.
Every project.

xZane is a hardware-agnostic AI execution runtime — the orchestrator and the enforcer. It routes AI commands, loads device schemas, builds a unified capability surface, and holds the deterministic line between what the model intends and what the device is allowed to do. It never touches hardware directly; it always goes through a HAL.

You write two things: a HAL adapter that speaks your hardware's language, and a capability schema that declares what your device is allowed to do. The schema is the containment mechanism — the model can only request what the schema explicitly sanctions.

Everything else — the enforcement engine, the audit logging, the reflex safety watchdog — is xZane. Write the adapter once. It's there on every project after.

AI model · natural language intent
xZane runtime orchestrator & enforcer
capability schema  ← you write this (what the device can do)
modules — reflex watchdog, perception, SLAM
HAL adapter  ← you write this (speaks your hardware's language)
Physical device · your existing firmware

Three things xZane enforces

Capability contract
Commands checked before the machine moves
You declare what your device can do — e.g. move.forward, speed 0–0.5 m/s, duration 100–10,000 ms. The model can only request what the schema explicitly sanctions. Anything outside the envelope is rejected before it reaches the hardware, not logged after the fact.
Reflex engine
The machine monitors itself independently
A separate mechanism monitors telemetry independently of the AI model. Legal commands stop mid-motion when the world changes. The AI and the safety monitor are deliberately separate systems.
Audit log
Every action logged, timestamped and traceable
Every command, every rejection, every safety stop — logged with full context: the traceability the EU Machinery Regulation expects for AI-driven machinery, and the record-keeping the EU AI Act's Article 12 requires where a system falls in its scope.
75–90%
reduction in software integration hours across a project lifecycle

In a traditional robot cell, the arm and hardware are only about 25–40% of total project cost.1 The majority goes to integration — engineering, programming, glue code, hardcoded safety logic and commissioning — which on its own routinely runs 30–50% of the project.2 A custom AI-enabled integration commonly takes 8 to 26 weeks.3 That's before the AI model changes, or the client adds another robot.

xZane's architecture eliminates the majority of that integration work at the source. Here's exactly where those hours go.

Write once
The HAL adapter is a one-time investment
In traditional setups, every new AI model or robot requires custom middleware. With xZane, a developer writes the HAL adapter once for a hardware model. Adding the 2nd or 100th robot of that type requires near-zero additional software integration time.
Safety layer
No custom safety middleware to build
Integrators typically spend hundreds of hours programming state machines and safety interlocks to prevent dangerous actions. xZane's schema-as-contract and mandatory Reflex module mathematically bound the robot's actions — the safety layer is already built into the runtime.
AI upgrades
Swap the AI model without touching the stack
Standard integrations require rebuilding the control stack when a client changes AI model — from Claude to a local Qwen or Mistral. With xZane, the new model targets the same capability schemas. The hardware doesn't know or care that the brain changed.
New capabilities
Modules deploy without regression testing the stack
Adding a new skill — SLAM, YOLO visual perception — is deployed as a self-contained module. Integrators don't have to regression-test an entire monolithic codebase to ship a new capability. The runtime manages module lifecycle; your stack stays intact.
xZane shifts system integration from a labour-intensive bespoke engineering project into a scalable, plug-and-play software deployment. The work your engineers do on the first project pays for every project after it.

Real responses. Real hardware.

These are actual xZane runtime responses from a ROS 2 robot. The same runtime architecture, unchanged, running across three different hardware stacks.

xZane runtime · response
rejected
// AI asked to drive forward for 2 hours
{
  "status": "rejected",
  "error_code": "parameter_out_of_bounds",
  "violations": [
    "duration_ms=7200000 exceeds max 20000"
  ],
  "intent": "robot.move.forward",
  "ts": "2026-08-12T20:03:52Z"
}
The command never reached the wheels.
xZane runtime · response
interrupted
// Legal command — stopped by the world
{
  "status": "interrupted",
  "outcome": "interrupted_by_reflex",
  "reason": "reflex_latched_mid_motion",
  "latch_reason": "front",
  "ai_command": null,
  "confidence": null
}
Reflex latched — front obstacle detected mid-motion.

Demonstrated across ROS 2 robotics, consumer appliances, and smart-home devices — same runtime architecture, three hardware stacks.

Overview ↗ Rejection ↗ Reflex stop ↗

The compliance scaffolding is already inside.

A robot cell is machinery, so its operative EU law is the Machinery Regulation (EU) 2023/1230 — mandatory from 20 January 2027, with no grace period.5 For the first time it requires a safety review of AI and self-evolving behaviour, a documented risk assessment of the integrated cell (ISO 10218-2), and traceable technical documentation. xZane produces the logging and the documented safety envelope this demands as a byproduct of normal operation.

Under the 2026 Digital Omnibus reform, AI-enabled machinery is governed by the Machinery Regulation rather than the EU AI Act's Chapter III directly, with AI-specific machinery requirements due by August 2028.6 Where a system does fall in the AI Act's own scope, the same audit log maps to its Article 12 record-keeping requirement — one layer covers both.

Two deadlines are already on the clock: the Machinery Regulation applies 20 January 2027 (no grace period), and AI-specific machinery requirements are due August 2028. Every AI-enabled cell you ship between now and then needs this layer.

Machinery Regulation + AI Act
Audit-grade logging
Every AI decision, every command validation, every safety stop — timestamped, structured and traceable: the record-keeping the Machinery Regulation expects for AI-driven machinery, and the EU AI Act's Article 12 where a system is in its scope.
ISO 10218-2
Documented safety envelope
The capability schema declares exactly what the AI is allowed to do. That declaration is the foundation of a risk assessment — already written, not assembled from scratch per project.
HAL execution boundary
Sits above your existing stack
xZane installs alongside your existing control and safety systems — not in place of them. You keep your firmware; xZane governs AI access to it through the hardware abstraction layer.

A bounded sprint,
not an open-ended project.

One device, one use case, 4–6 weeks. We write the HAL adapter together. At the end, xZane is running live on your hardware — and your engineers understand every part of it, ready to reuse it across hardware variants.

Standard pilot
€10,000
Single device · Standard hardware · 4 weeks
UR · FANUC · ABB and equivalents
xZane running live on your machine
HAL adapter — written and owned by your engineers
Audit logs for Machinery Regulation & EU AI Act traceability
SDK access — write future adapters without us
2–3 hours/week of your engineer's time
Extended pilot
€25,000
Multi-device cell or custom hardware · 6 weeks
For less common hardware or multi-device installations
Everything in the standard pilot
Multi-device cell integration
Custom hardware HAL adapter development
Ground Control UI — operators monitor AI decisions in real time
Ongoing license
€400–€600 per device per year
A 10-device cell runs at €4,000–€6,000/year — a line item against the cost of the cell. xZane installs on a central hub; devices connect via HAL adapters.
Start a conversation →

Built by the engineer who architected it.

xZane was personally designed and built by Julio Chinchilla — the runtime, the validation gate, the independent reflex mechanism, and the hardware abstraction layer. The work spans runtimes, data platforms, and embedded systems, built between Vilnius and Tallinn.

A US non-provisional patent is filed. The SDK is ready to hand to a first integrator.

Entity
ZillA Technologies OÜ · Estonia
Based
Vilnius, Lithuania · Tallinn, Estonia
IP
US patent pending (USPTO)

A described device is enough to start.

Tell us a little about your device and what you'd want a pilot to prove. A 30-minute call is usually enough to scope whether the pilot makes sense for your project.

Or write directly to [email protected]

What we need from you
One machine or test cell
A use case — what you'd want it to do through xZane
2–3 hours per week of an engineer's time
xZane · pilot enquiry
Open the enquiry form →

Or email [email protected]

No commitment required. A described device is enough to start — we'll take it from there.
  1. 1.Robot hardware is typically only 25–40% of total cell cost (the "30% arm rule"); integration is the larger share. AMD Machines, True Cost of a Robot: 5-Phase TCO Breakdown; Zeueeauto, Robot Integration Guide.
  2. 2.Integration (engineering, programming, safety logic, commissioning) routinely runs 30–50% of total project cost. AMD Machines, TCO Breakdown; corroborated in Cost of deploying robotics on a factory floor (2026).
  3. 3.Custom robot integrations commonly take 8–12 weeks; full custom cells 12–26 weeks. Zeueeauto, Robot Integration Guide.
  4. 4.Total integrated system cost typically runs ~2–3× the robot arm alone ($150k–500k vs $50k–200k). Standard Bots, How much do robots cost? 2026 breakdown.
  5. 5.Machinery Regulation (EU) 2023/1230 applies from 20 January 2027 with no grace period, and for the first time requires a safety review of AI and self-evolving behaviour. EU-OSHA; Pilz.
  6. 6.Under the 2026 Digital Omnibus, AI-enabled machinery is governed by the Machinery Regulation rather than the EU AI Act's Chapter III directly; AI-specific requirements are to be added via delegated acts by 2 August 2028. Inside Global Tech; Winston Taylor.

Cost and timeline figures are industry ranges and vary by application; regulatory positions reflect the state of EU law as of 2026 and are not legal advice.