AI for Embedded Systems: What Agentic Development Requires in Production

Embedded software development has always demanded a different kind of discipline than general software development for desktop, mobile, or web. There is no cloud instance to scale out of trouble or an easy way to get more memory when you run out. Further, a system crash doesn’t affect just the use of an office application, which can be recovered from the last saved status, but instead, an embedded software error can cause a vehicle, a medical device, or industrial equipment to stop working, raising the stakes considerably. This distinction should shape how any organization evaluates their use of AI for embedded systems before committing budget or engineering time to it.

What makes agentic development production-ready for embedded hardware?

Production-grade agentic development requires the alignment of three aspects:

1. A UI- and hardware-aware set of agent skills built for the target platform,

2. Dedicated, human-in-the-loop reviews so that you don’t rely solely on agents’ judgment.

3. Clear organizational accountability for what ships.

Organizations evaluating embedded AI tools should treat all three as prerequisites, not optional refinements.

Qt recently hosted a panel discussion on the state of AI for embedded systems with Jacob Beningo from Beningo Embedded Group, Przemyslaw Nogaj from Spyrosoft, and Peter Schneider from Qt Group. The panel highlighted common challenges that embedded teams are currently facing with getting their agentic code reliably into production.

Why AI for Embedded Systems Matters Now

For the first several years of the AI coding wave, productivity gains concentrated almost entirely on web, desktop, and mobile software. Embedded development lagged behind, partially probably because of volumes, partially for a structural reason: target devices tend to come with memory constraints, the often-missing GPU to offload work to, and specific hardware requirements that general-purpose agentic coding models were not trained against.

Today, that gap is closing quickly. The last six to nine months have shown a visible shift even in traditionally cautious or regulated industries. Medical device manufacturers that ruled out AI-assisted development outright a year ago are now setting internal targets for the share of committed, approved code that must be AI-generated. Defense contractors are evaluating which large language models (LLMs) can be deployed inside their own data centers rather than through a public cloud API.

While embedded product cycles remain slower than consumer software, with realistic adoption in regulated industries between two to five years, the trajectory is no longer in question. Organizations that wait risk ceding a productivity advantage to competitors who move first.

The Common Challenges of Embedded AI Tools in Production

The gap between experimenting with AI and deploying it in production is where most organizations underestimate the work involved. Four challenges recur consistently for teams putting embedded AI tools to work on real hardware:

• Hardware awareness. General-purpose LLMs are trained on patterns suited for desktop, web, or mobile applications, making them fall short for a resource-constrained HMI device.

• Memory and cycle budgets. Every optimization decision must respect fixed constraints on binary size and CPU cycles of the target hardware.

• Confidentiality. Especially for safety-critical embedded systems, sending data to a cloud-hosted, shared model may not be an option, shifting workloads toward privately hosted instances, or on-premises or smaller local models.

• Simulation blindness. Performance issues that are invisible on a desktop build or in a simulation can be severe on the actual target device, making it necessary to do proper validation on the real hardware.

None of these constraints is new to embedded software development. What's changed is that, given the right context, an AI agent can now be directed at them specifically.

Can You Trust AI-Generated Code for Embedded or Safety-Critical Devices?

The direct answer is no, not by default. You can’t trust generated code directly for desktop or mobile applications, either, but the stakes are fundamentally higher when the target is hardware in production use.

A useful analogy was raised in the embedded AI panel discussion: today’s coding agents resemble a highly credentialed new graduate, qualified in theory but falling short in practical understanding of a specific codebase. Left unsupervised, that combination can just as easily break existing functionality while adding a new feature. This is the core issue for embedded devices specifically: code generated with apparent confidence is not the same as code verified as correct.

Organizations should look at AI agents as a tool, not as a shortcut. It pays off to put effort into carefully defining requirements before any code generation takes place, and to gate what output is accepted with validation checklists. The agent must operate under supervision, not as an unsupervised decision-maker.

Who Reviews and Tests the Code? Why Agentic AI Systems Still Need a Human Reviewer

With agents producing code faster and faster, code review is becoming the new bottleneck. Partially, this can be solved by agentic code reviews paired with deterministic, static code analysis. However, agentic reviews and quality assurance should rather be looked at as a first-pass filter, not a final approval.

At its simplest, domain-specific agent skills help improve the generated code quality. For instance, the QML profiler skill can identify UI bottlenecks systematically rather than through manual inspection, or memory profiling can help keep the performance in the right bounds. Qt has published a set of such agent skills and MCP tools built for exactly this kind of hardware-aware review.

That’s not enough, however. For instance, a useful model could be to borrow from traditional code review practices: an approval needs both an agentic review, catching what a human might miss, and also a human-conducted final approval. Static analysis on top of agentic judgment should also stay in the pipeline, since regulated industries are always going to need a specified and auditable review step.

Regulatory Compliance: How Software Development with Agentic AI Meets CRA and Similar Regulations?

Regulatory compliance, applicable in more and more industries, raises the stakes of code quality and security even higher.

The EU's Cyber Resilience Act (CRA), applying to devices with software elements, places liability for cybersecurity directly on the device manufacturer throughout the product lifecycle. Comparable regulations are advancing across the globe from Americas to APAC. As software becomes a larger share of every product's risk surface, regulators are holding vendors accountable for the entire stack, including any code an AI agent helped produce.

AI for embedded systems doesn’t have to collide with regulatory compliance when implemented correctly. Quite the contrary. Agentic workflows can monitor known vulnerabilities and maintain code traceability. Organizations that build their products on a framework that satisfies regulatory obligations, pairing agentic AI for embedded systems with stable libraries and tooling that validates code against a defined standard automatically can, in fact, help assure compliance better than just relying on manual efforts alone.

Performance: Can AI Agents Optimize UI Code for Target Embedded Hardware?

Especially in embedded development, functional correctness isn't the finish line. The code must run within strict performance constraints on the actual target device. Costs invisible on a desktop or simulation environment can turn out severe on real hardware, making optimization work necessary with a hardware-in-the-loop setup.

An autonomous agent loop can make this easier and more efficient, however, already today. For instance, to reduce the binary size and CPU cycles, agents can modify the code, deploy to the board, collect telemetry, and determine the next iteration. And the agents can do this ten times faster than humans manually can. But it’s important to keep in mind that simulation and desktop proxies aren't substitutes for this kind of tuning; performance work on embedded devices must close the loop on the actual hardware.

Human in the Loop: How Agentic AI Systems Are Changing Embedded Software Development

None of this implies that developers become passive observers. AI brings a shift in responsibility, moving developers from writing every code line to orchestrating a system in which agents contribute; defining the technical specification, setting constraints, verifying architecture, and directing the review. It can be compared to the past shift away from hand-written assembly once compilers matured; agentic AI systems are bringing along a similar shift one layer higher, freeing time from repetitive implementation work to system-level thinking.

How the role evolves. Senior engineers will face a skill shift: they will need the ability to assess generated code efficiently, spotting an architectural flaw quickly rather than reading every line sequentially. It can be a positive challenge, moving time spent on repetitive tasks to more impactful, creative work.

How hiring decisions are impacted. Hiring criteria is already changing from tool familiarity to demonstrated curiosity and adaptability. It’s good to acknowledge, however, that if future junior engineers have less hands-on coding experience, they may need mentorship to develop the instinct for what can go wrong.

Why this improves retention and output quality. Repetitive implementation work is what agents absorb most effectively. The recovered time goes toward the work that retains talent: solving new problems, understanding systems holistically, and building rather than reproducing prior work.

The Future of AI in Software Development for Embedded Devices

Agentic development doesn't reduce the rigor that embedded engineering requires. Instead, it raises the bar for what "reviewed," "tested," and "compliant" mean, while giving organizations more capacity to meet that bar. Organizations that treat this shift in AI for embedded systems as a structural change to embedded software development are positioned for a durable advantage. Those that defer aren't avoiding risk; they're deferring a capability gap that will be more expensive to close later.

Agentic Development Across the Full Software Lifecycle