MyTechDailyNews Software Guide: Agentic AI Is Becoming Embedded Software’s Productivity Layer

By Sarah Chen | MyTechDailyNews Software

If you maintain firmware, board support packages, or device SDKs, the most practical change in agentic AI is not a new language; it is a new layer that reads project context, calls existing tools, and keeps humans in the review loop. For embedded software teams, that means agents are becoming productivity layers around real toolchains rather than standalone coding assistants.

What software teams should take away

• Natural language is becoming a working interface for existing embedded software tools, not a separate runtime language.
• Generated code still needs device context: wrong pins, clock configuration, deprecated APIs, and missed initialization steps are practical failure modes.
• Safety work increasingly depends on reviewable properties, oracles, guardrails, and traceability rather than line-by-line trust in LLM output.
• Privacy posture differs by tool: local workspace analysis, data remaining on the developer’s system, firewall operation, and customer-controlled model access are recurring themes.
• The efficiency story is toolchain-specific: AMD cited a 300-megapixel sensor example moving from two days to two hours and from 1801 lookup tables to 1177 LUTs.

AMD Ross: a harness around the software stack

Kirk Saban, vice president for Product, Software and Solutions at AMD, framed the change as “Natural language as the new abstraction layer for embedded in both the hardware and software domains,” and said, “The fundamental game changer has been the advent of large language models (LLMs) with the ability to describe the problem in natural language.” Speaking to eeNews Europe, Saban added, “One of the key things we see in embedded is that we deal with all different types of domains, form factors, use cases, and that requires a lot of different disciplines and architectural trade-offs,” and noted, “There’s often many manual handoffs and there are lots of different tools out there and as the chips have become more complicated so have the tools.”

For AMD, that direction has produced Ross, an interface harness that lets its toolchain communicate across multiple tools. The name follows Anthropic’s Claude AI convention and honors Ross Freeman, inventor of the Field-Programmable Gate Array (FPGA), former director of engineering at Zilog, and a co-founder of Xilinx, alongside Bernie Vonderschmidt and James Burnett. Saban said, “AMD Ross spans the entire paradigm of our development stack, running alongside and plugging into all the different tools,” and covered AMD tools from Vivado FPGA design tools and Vitis unified IDE development environment to Ryzen embedded processor AI tools and ChipScope integrated logic analyzer.

“We are not in the business of creating LLMs – Ross will plug into any of the public model providers, but we also support open weight models. It’s a harness across our entire development stack. We are giving a harness for you to adapt to your design environment,” Saban said. “It is the same with IDE tools, we work with all the major players in the industry.”

Quick comparison: toolchains, guardrails, and software scope

Tool	Software role	What to check first
AMD Ross	Interface harness across AMD development tools	Model routing, firewall or airgap, skills, and MCP access
AdaCore with GNAT Pro	AI support for Ada, SPARK, safety code	SPARK Silver, SPARK Gold, SPARK Platinum properties and human review of Gold level properties
ModusToolbox AI Assistant	VS Code extension for PSOC devices	Local workspace analysis, device/board/peripheral context, data remaining on developer system
Tasking winIDEA	Agentic debug and analysis workflows	Requirements traceability, guardrails, certification needs
Clate	No-code embedded UI tool generating QML	Hardware constraints, design prompts, planned feature timing

Formal safety: AdaCore’s path from Ada to SPARK

AdaCore is applying AI to embedded code for safety-critical systems, using Ada, SPARK, and GNAT Pro. Mark Hermeling, head of technical marketing at AdaCore, said, “We know that Spark requires an additional level of effort. You can write it without the additional formal methods, but it is harder,” while explaining that “But if you have Ada code and you want to lift that to SPARK Silver [to guarantee the absence of runtime errors], AI can do that in an LLM, every time. This is a tremendous offload for the developer.”

Hermeling described taking a standard STMicroelectronics C data-gathering demo, converting it to Ada, and lifting it to SPARK Silver on a laptop during a flight from Los Angeles to Toronto. That work produced six areas for inspecting incoming data and can also set selected functional properties, typically for safety or security, at the next level; SPARK Gold and SPARK Platinum cover the full formally proven design for safety critical code such as automotive, aerospace or encryption. “So whatever AI does it can never violate those requirements, so it’s really easy for developers to elaborate the code while staying completely safe,” he said.

Step tutorial: lifting Ada toward SPARK Silver

1. Start from an Ada project, such as the STMicroelectronics demo Hermeling described.
2. Take the skills from the Github repository; the AI support is delivered through that repository.
3. Use the Connect skill, which codifies SPARK best practices.
4. Use the Prove skills so agents follow a pattern that lifts the Ada code to SPARK Silver.
5. Review the functional properties, especially at SPARK Gold and SPARK Platinum, so the design remains aligned with safety or security constraints.

The AI support is delivered through a skills repository hosted on Github. “This includes what we have learned over the last six to nine months,” he said. “We started with Model Context Protocol (MCP) but this is not necessary for command line tools, the skills do that. Specifically, the Connect skill codifies SPARK best practices. Grab the skills from the repo and use the Prove skills. This spawns a set of agents in a particular pattern to lift the Ada code to SPARK Silver,” he said.

“What GNAT Foundry provides is a workflow for agents to follow the V-model for requirements. There’s an agentic framework with discrete steps and for each step there is an oracle that checks whether the AI is doing the right thing,” he said. The repository has been cloned by 250 people so far. It contains an example high integrity traffic light system that can be extended with AI, moving from high level requirements to low level code while maintaining Gold-level properties.

“The frontier models are brilliant, but LLMs are intelligent parrots that are trained on poor C code as perfect C code doesn’t exist. One of the challenges with AI is its ability to generate vast amounts of code that you can’t possibly verify,” said Hermeling. “With GNAT Foundry you don’t have to. As long as an engineer has reviewed the Gold level properties then it doesn’t even matter if every single line of code has been tested.”

He cited automotive ISO 26262 ASIL-D safety critical code where a frontier model found a handful of memory violations and also provided exploits. “Customers can fix those violations but next week’s model will find more. We have to find a different way of doing software engineering,” he said. “Writing code becomes less important, software engineering becomes more important – you come up with the design and how to componentise, that’s what the Gnat example shows,” he said. “There’s a ton of pressure to write and ship so I would always wrap code with as many oracles as I can – that’s what people have to keep in mind – LLMs like humans can make mistakes.”

Infineon: device-specific context in ModusToolbox and VS Code

Infineon Technologies is broadening ModusToolbox with the ModusToolbox AI Assistant, an AI coding assistant extension for Microsoft Visual Studio Code (VS Code). Because embedded software depends on exact hardware setup, an incorrect pin assignment or omitted clock configuration can force teams to spend hours debugging physical boards; generic assistants may miss device-specific context.

The ModusToolbox AI Assistant gives AI coding agents hardware-specific context for PSOC Edge and PSOC Control controllers. Without that context, generated code can look plausible but fail on real hardware, target the wrong device, call deprecated APIs, or skip initialization steps that appear during board bring-up. Each suggestion is tied to the developer’s actual target device, board, and peripheral configuration. Project context is evaluated locally, and customer project data remains on the developer’s system. Typical uses include connected IoT devices that combine graphics and connectivity functions.

The assistant obtains context through local workspace analysis. It inspects the project structure, board support package, installed middleware, code examples, and available tools, then gives the AI agent device-specific instructions and development skills. Coverage includes peripherals such as GPIO, I2C, SPI, UART and DMA, along with connectivity and RTOS functions. With that targeted context, the agent can generate more accurate code while consuming fewer tokens.

Before code generation, it creates a project plan for developers to review and refine, specifying the target device, board, libraries, and project structure. The workflow also supports migrating existing projects to other Infineon devices; future releases will add support for PSOC 4, PSOC 6 and TRAVEO T2G families.

Tasking: traceability inside winIDEA

Embedded teams, especially those building complex, multicore applications, must deliver increasingly complex, functionally safe software within tighter timelines. Although AI can help write, test, and verify software, requirements traceability still puts full responsibility for all AI activity on developers.

Tasking has introduced certifiable agentic AI for embedded debugging analysis. Developers can choose their own LLM and agentic AI to automate software development, but the setup supports requirements traceability and simplifies certification to functional safety standards.

AI agents can connect to Tasking’s unified toolchain through the winIDEA development environment using the tools and files. When agents are reachable inside the development toolchain, developers can automate several workflows; that speeds software design and verification while preserving strict requirements traceability for certification.

Within Tasking’s winIDEA software workflows, the tools integrate AI and give generically trained LLMs context on how code or scripts should be generated. That improves productivity while keeping the requirements traceability needed for certification to industry standards. Guardrails limit what AI may do, and human oversight keeps accountability intact as AI supports the development lifecycle without compromising reliability, functional safety, or security.

“Our approach to AI accelerates complex, multicore embedded development by giving agents structured access to debug and analyse workflows,” said Janez Ulcakar, Director of R&D Debugger Solutions at Tasking. “This enables agentic-based automation to work with real-time debug evidence while ensuring engineers remain in full control of AI processes and conclusions. This is essential for systems that need to be certified to functional safety standards.”

The winIDEA AI Kit brings together three maintained components. The first is an MCP server that provides structured access to design tool capabilities, including debug control, memory, variables, breakpoints, trace, coverage, profiling, and timing analysis. AI-ready winIDEA SDK documentation helps agents create accurate automation scripts in supported programming languages, while embedded-development skills provide task-oriented guidance and context for debugging, timing analysis, winIDEA configuration, and device-specific workflows. As a result, teams can ask an AI agent to perform tasks rather than build and maintain a large library of custom scripts or tool instructions.

Skills, access, and the future embedded software stack

“You can use LLMs such as Claude today to run tools such as Vivado and we will be working on all the point tools to make them more agentic friendly with output files that are more friendly to agentic tools,” said Saban at AMD. “We use MCP which is Anthropic’s database interface to LLMs. Through MCP servers we will give access to our entire knowledge base with access to all the documentation.”

“The other piece is making skills available, such as design rules for board layout, best practices for timing closure in an FPGA, published through the agent skills repository. We also see that customers will want to use the knowledge in their own way and they can plug that into their own workflows.”

“We understand the importance of the airgap for safety and security. Ross can run inside the firewall so you are not putting anything into the public domain. The customer gets to decide the level of access to models and data. We use Claude in AMD sandboxed and firewalled with an LLM gateway.”

Saban described Ross as building a skills ecosystem around AMD devices. “We can provide specific skills, for example pipelining, timing closure, partitioning but customers can deploy their own skills internally or to publish, and partners can develop skills. We have design and tool agents, a specification agent and a code creation agent. We will publish 20 skills with the initial release but this will expand rapidly,” he said.

“We know the embedded development community very well, they need to be in control, we are very conscious of that and Ross is working alongside the engineers.”

The repository will expose all the skills, although industry-level challenges still need to be solved. The skills are initially plain text markdown files, and that format will evolve. “We are actively evaluating this. Initially it will be in a repo as a plug in with the skills and MCP server and through the MCP server you get access to the AMD database so it gets you to an answer more efficiently with less tokens,” Saban said.

One cited data point is a 300-megapixel sensor development with an FPGA for image processing. In that case, handwritten C++ code for the HLS algorithm takes two days and uses 1801 lookup tables in the FPGA, while Ross completes the work in two hours and uses 1177 LUTs. Designers have had early access since June, with over 800 customers using it for FPGA development in Vivado, and monthly updates are planned.

No-code UI, QML, and language choices

The shift toward AI agents is also changing how code is developed, moving work away from languages such as C++ toward memory-safe Rust with AI support, digital twins with AI models of components, and no-code development environments.

The Qt group, whose portfolio includes the IAR development tools, has built an AI-native, no-code tool for embedded interfaces.

Clate is currently in beta testing and seeks to reduce reliance on generic web and mobile design tools. Its AI-native integration supports natural language prompting for actions such as screen generation and design changes, and it uses MCP to connect directly with other design and productivity tools. It outputs production-ready QML code, a declarative programming language designed for building user interfaces.

“For too long, embedded UI/UX designers have had to compromise their work, using web-centric tools that simply don’t account for real-world hardware constraints,” said Antti Kujala, Vice President, Design Products at Qt Group. “We created Clate to end that compromise, and to give designers back full control and ownership of the user experience. Designers won’t need in-depth knowledge of code either. Clate runs on Qt, and generates QML production-ready code automatically in the background. And, as an AI-native workspace, Clate connects across a designer’s ecosystem through standard MCP protocols, allowing teams to prompt changes using natural language, without disrupting their natural flow. For the first time, designers can be confident that the UI and UX they create will be exactly what the end-user experiences.”

A suite of planned features is set to arrive in early 2027 with AI assistants, integrations, and production-ready QML code output. Embedded hardware optimization features, including frame rate and memory consumption checking, will follow shortly after the initial release.

Asked whether Ross could support a digital twin, Saban at AMD said, “To do that there are several things that need to happen. Some of the IP models need a software-centric model and some of that IP is ours, some is from third parties, we don’t have a firm plan today but I can see the industry moving to that over time and the whole ecosystem needs to evolve,”.

“If people starring new projects in C++ right now I really question whether that’s the right thing to do, why would you not start in Rust,” asked Hermeling at AdaCore. “There’s enough libraries for that and AdaCore is working to get there with Rust. We support Rust to the same level as Ada as we understand that people want to use it unless you have requirements for high levels of high integrity and then Ada does that.”

FAQ for embedded software users

Are these tools trying to replace engineers?

No. Ross, the ModusToolbox AI Assistant, winIDEA AI Kit, and Clate are positioned to work alongside developers, with plans, guardrails, oracles, or human review before generated results are accepted.

Is the data local?

For ModusToolbox, project context is evaluated locally and customer project data remains on the developer’s system. For AMD, Ross can run inside a firewall and customer decides access to models and data.

Should teams switch from C++ to Rust?

Not automatically. Hermeling questioned starting new C++ projects and pointed to Rust, while AdaCore said it supports Rust and Ada depending on integrity requirements.

How should teams judge generated embedded code?

Look for device-specific context, traceability, certification support, and verification gates such as oracles or SPARK property review.

Common misconceptions

• Generated code that compiles is ready for hardware: plausible code can still target the wrong device, call deprecated APIs, or skip initialization.
• AI removes the need for requirements: requirements traceability still puts full responsibility on developers.
• Every team needs its own model: Ross plugs into public providers and open-weight models, and AdaCore’s workflow can use skills without command-line MCP.
• UI design can be separated from constraints: Clate is designed for hardware-aware UI work and outputs QML.

Action recommendations

• Before adding an AI coding agent, inventory the toolchain, board support packages, middleware, examples, and installed tools, because that is the context local analysis can inspect.
• Decide in advance whether model access will use public providers, open-weight models, or a sandboxed, firewalled route, and define who controls data access.
• Require a project plan or reviewable step list before code generation, especially when the assistant targets specific devices, libraries, and peripherals.
• For safety or certification work, map which properties are reviewed by humans, such as SPARK Gold or Gold-level properties, and keep requirements traceability visible.
• Use early-access data points—such as AMD’s 300-megapixel sensor example—as evidence for time or LUT savings, but verify on your own target.