WorldIndustrialWeekly General: Natural-Language Harnesses, Formal Oracles, and Traceable Debuggers for Embedded AI Agents

Manufacturing leaders, production owners, engineers, and supply-chain decision-makers are now encountering agentic AI inside embedded development workflows. The practical change is not a new single tool but a productivity layer that can describe hardware, software, safety constraints, debug evidence, and interface requirements through natural language.

Prepared by Michael Torres for WorldIndustrialWeekly’s General coverage. Editorial contact: news@industrialweekly.com.

1. The shift at AMD: a harness around the development stack

Kirk Saban, vice president for Product, Software and Solutions at AMD, framed the movement in the same interview with eeNews Europe: “Natural language as the new abstraction layer for embedded in both the hardware and software domains,” he said. “The fundamental game changer has been the advent of large language models (LLMs) with the ability to describe the problem in natural language.”

“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,” Saban told eeNews Europe. “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 produced Ross, an interface harness that lets the company’s toolchain communicate across multiple tools. Ross is also a naming choice: it follows Anthropic’s Claude AI convention and honors Ross Freeman, inventor of the Field-Programmable Gate Array (FPGA) and 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 that reach covers 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.”

2. AdaCore: using SPARK proof levels as agent constraints

AdaCore is applying AI to embedded code for safety-critical systems while using Ada, SPARK, and GNAT Pro. Mark Hermeling, head of technical marketing at AdaCore, explained the trade-off: “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.”

The case Hermeling gave is a demonstration of incremental formal lifting: a standard STMicroelectronics C data-gathering demo was converted into Ada, then lifted to SPARK Silver during a flight between Los Angeles and Toronto. The result included six areas for inspecting incoming data, and the method 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.

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.”

Hermeling 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.”

3. Infineon: hardware context before code generation

Infineon Technologies is broadening its ModusToolbox tools with an AI assistant extension for microcontrollers. Embedded work depends on exact hardware setup, so an incorrect pin assignment or omitted clock configuration can force teams to spend hours debugging physical boards.

The ModusToolbox AI Assistant for Microsoft Visual Studio Code (VS Code) gives AI coding agents hardware-specific context for PSOC Edge and PSOC Control controllers. Without that context, generic AI coding assistants can produce code that looks plausible but fails on real hardware, such as output targeting the wrong device, calling deprecated APIs, or skipping an initialization step that only becomes visible during board bring-up. Every suggestion is tied by the ModusToolbox AI Assistant 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.

That context is obtained by the ModusToolbox AI Assistant through local workspace analysis. The analysis looks at the project structure, board support package, installed middleware, code examples, and available tools. The extension then uses that review to give 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 targeted context, the AI agent can generate more accurate code while consuming fewer tokens.

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

4. Tasking: traceable debug evidence 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 may 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 AI 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 developer 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.

5. Skills, airgap, and measurable workbench data

“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, he said. “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,” said Saban.

Workbench measurement	Reported figure
300-megapixel sensor	FPGA image-processing task
two days	handwritten C++ code for the HLS algorithm
1801 lookup tables	FPGA resource use for handwritten C++ code
two hours	Ross completes the work
1177 LUTs	FPGA resource use with Ross
June	early access began
over 800 customers	using it for FPGA development in Vivado
20	skills in the initial release

6. No-code embedded UI, digital twins, and memory-safe code

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,” asks 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.”

Case evidence for managers

• AMD Ross example: A 300-megapixel sensor development with an FPGA for image processing compares handwritten C++ code for the HLS algorithm with Ross output.
• AdaCore example: A STMicroelectronics C data-gathering demo was lifted from Ada to SPARK Silver on a laptop during a flight from Los Angeles to Toronto.
• Tasking example: winIDEA AI Kit components let agents access debug control, memory, variables, breakpoints, trace, coverage, profiling, and timing analysis under human oversight.

Common misconceptions

1. Misconception: Agentic AI means the hardware toolchain is replaced by a model.
2. Correction: AMD Ross is described as a harness that plugs into existing tools, including Vivado, Vitis, Ryzen tools, and ChipScope.
3. Misconception: Safety-critical code can rely on generated code alone.
4. Correction: AdaCore places SPARK Silver, SPARK Gold, and SPARK Platinum properties, oracles, and GNAT Foundry workflows around the agent.
5. Misconception: Generic AI assistants always understand target devices.
6. Correction: Infineon’s ModusToolbox AI Assistant supplies local board, peripheral, middleware, and project context for PSOC Edge and PSOC Control.
7. Misconception: AI automation removes accountability.
8. Correction: Tasking winIDEA maintains requirements traceability, guardrails, and human oversight for certification.

Action recommendations

• Ask vendors to show the artifact chain: requirements, model or oracle, tool output, and evidence used in review.
• Require local or sandboxed context before accepting AI-generated embedded code; verify device, board, pin, clock, peripheral, middleware, and initialization steps.
• Use formal or traceability layers where standards matter: SPARK proof levels, ISO 26262 ASIL-D review, and requirements traceability in winIDEA.
• Treat skills repositories, MCP servers, and LLM gateways as governance assets, not only convenience plugins.
• Measure productivity and resource effects, including time and lookup tables, before scaling across teams.

FAQ

Q: Is the purpose of agentic AI in embedded toolchains to remove engineers?
A: No. The material points to a productivity layer for hardware and software design, with engineers retaining control, review duties, and accountability.

Q: Why does device context matter in AI-generated code?
A: Because embedded output can fail on real hardware if the agent lacks the target board, peripherals, middleware, and configuration constraints.

Q: How do SPARK properties help when AI generates code?
A: Selected functional properties can be set first, then the agent is constrained by those properties and by oracle checks.

Q: What should supply-chain or operations managers ask about airgap deployments?
A: They can ask whether the agent can run inside the firewall, who controls model and data access, and whether output remains local to the developer’s system.