AIdataNewsGlobal AIApplications: Embedded Agent Workflows, Safety Guardrails, and Action Steps

For the AIApplications reader on AIdataNewsGlobal, the practical question is where an agent should sit inside an embedded delivery workflow: code editor, hardware configurator, debugger, UI design tool, or documentation server. The companies named below—AMD, AdaCore, Infineon Technologies, Tasking, and the Qt group—show that the value is not a stand-alone chatbot but a context-aware layer that can run alongside existing tools. The application angle matters because generated code, board configuration, and interface output must be checked before they become hardware, certification evidence, or shipped firmware.

Application view 1: an agent harness beside the AMD toolchain

Kirk Saban, vice president for Product, Software and Solutions at AMD, described the application shift 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 summarized the embedded complexity: “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,” then added, “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.”

That framing produced Ross, an interface harness. 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.

“AMD Ross spans the entire paradigm of our development stack, running alongside and plugging into all the different tools,” Saban said. The 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.

For an application team, Ross’s position is important: “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.”

Application view 2: AdaCore and the safety-first path to SPARK

AdaCore applies the same application logic to Ada, SPARK, and GNAT Pro. Mark Hermeling, head of technical marketing at AdaCore, noted, “We know that Spark requires an additional level of effort. You can write it without the additional formal methods, but it is harder,” while adding, “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.”

In a concrete workflow example, Hermeling took a standard STMicroelectronics C data-gathering demo, converted it to Ada, and lifted it to SPARK Silver on a laptop during a flight from Los Angeles to Toronto. The work produced six areas for inspecting incoming data. Teams 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 delivery route for these skills runs through a repository 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.

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

Application view 3: Infineon device context and Tasking traceability

Infineon Technologies extends ModusToolbox with an AI assistant inside Microsoft Visual Studio Code (VS Code). For application teams, the value is workflow placement: the ModusToolbox AI Assistant gives AI coding agents hardware-specific context for PSOC Edge and PSOC Control controllers. Without device context, generic assistants can generate code that looks plausible but targets the wrong device, calls deprecated APIs, or skips initialization that appears during board bring-up.

The extension ties every suggestion 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 context is obtained through local workspace analysis of 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 that targeted context, the AI agent can generate more accurate code while consuming fewer tokens.

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

Tasking has also 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. Within Tasking’s winIDEA software workflows, 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.”

AI agents can connect to Tasking’s unified toolchain through winIDEA using tools and files. 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.

Application view 4: skills, security, and measured workflow gain

For teams evaluating AI applications, the next question is what knowledge is exposed and how it is governed. Saban said, “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,” and added, “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.”

He continued, “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.”

Security and deployment are part of the application design: “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.”

The skills plan also includes pipelining, timing closure, and partitioning, with customer and partner skills possible. “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, while industry-level challenges remain. The initial format is plain text markdown and will evolve. “We are actively evaluating this. Initially it will be 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.

A concrete measurement point cited by AMD is a 300-megapixel sensor development with an FPGA for image processing. Handwritten C++ code for the HLS algorithm takes two days and uses 1801 lookup tables (LUTs) 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.

Application view 5: Clate, Qt, IAR, Rust, and digital-twin limits

The shift toward agents also changes language and interface tooling. 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,” he said. “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.”

AIApplications checklist: embed agents where work is verifiable

Use this checklist before piloting agentic AI in embedded or hardware-adjacent product work:

• Map the task to a toolchain node: code editor, VS Code extension, debugger, FPGA flow, UI design tool, or documentation server.
• Check context: device family, board support package, middleware, peripherals, target hardware, and certification constraints.
• Define the human review point: plan approval, traceability export, oracle result, or signed-off requirements.
• Measure value: tokens saved, bring-up hours reduced, code review effort changed, or certification evidence made.

Step tutorial: run an embedded AI agent pilot

1. Select one narrow, non-release-critical workflow, such as peripheral initialization, debug scripting, or UI screen generation.
2. Connect the agent through MCP or an equivalent interface only after tool access is limited to the project workspace.
3. Ask the agent to produce a project plan, not just code, and have an engineer refine target device, libraries, and project structure.
4. Generate code with device-specific context, then run local checks: build, lint, static analysis, formal properties, and board bring-up tests.
5. Record evidence: requirements traced to tests, model access log, reviewer sign-off, and defect findings resolved or accepted.

Common misconceptions about AI in embedded work

• “The model will choose the right hardware.” Without device context, agents can look plausible but fail on boards.
• “Generated code is safe because it is new.” Formal oracles, SPARK properties, or traceability checks are still needed.
• “No-code means no engineering.” UI output still enters embedded firmware and must respect frame rate, memory, and certification constraints.
• “One AI sprint solves certification.” Standards such as ISO 26262 ASIL-D require requirements traceability, human control, and repeatable evidence.

Action suggestions for teams

• Start with local context and local data handling before connecting to public model providers.
• Prefer harness-style tools that plug into existing IDE, FPGA, debug, and UI toolchains.
• Wrap every generated asset with oracles: formal checks, device constraints, and traceability exports.
• Build a skills repository with review, versioning, and access controls; treat skills as product knowledge, not casual prompts.

The application conclusion is simple: agentic AI becomes useful in embedded work when it is placed next to the engineer, bound to device truth, and made auditable. Teams that treat agents as productivity layers rather than black-box code writers can move from “generate code” to “verify, certify, and maintain real products.” That is the practical standard AIdataNewsGlobal recommends when reviewing toolchain AI for business use.