How Agentic AI Accelerates Edge AI Software Development
Deploying an AI model on edge hardware involves much more than generating application code. The model needs to be compressed or quantized to fit available memory, compiled for a specific processor, integrated with a runtime, and tested for latency, power consumption, and accuracy. Developers must also make the software work with the surrounding embedded components and validate its behavior on physical hardware.
These stages are handled through separate development tools and manual steps. Agentic AI connects much of that workflow. Rather than only generating the code, a development agent works with compilers, test frameworks, profilers, debuggers, documentation, and other engineering tools to determine the next action.
This shortens the development cycle that previously required repeated manual work. But embedded systems create a difficult boundary for this level of automation. The deeper an agent moves into deployment, optimization, and hardware integration, the more it has to understand the target system to verify and trust results.
Agentic AI connects fragmented workflows
Typical embedded software development is divided into many different tools. For instance, an engineer starts with understanding the requirements, moves into a model or source code, configures a build system, compiles the software, creates test cases, searches documentation, inspects logs, and returns to the code for diagnosis. Edge AI adds additional steps to this model, including quantization, graph optimization, runtime selection, and deployment to the target process.
Agentic AI reduces manual switching between different tasks. The agent can work toward an engineering objective by choosing a sequence of actions, invoking available toolchains, checking the output, and deciding what to do next.
Vinesh Sukumar, who leads the AI and machine-learning product management team at Qualcomm Technologies Inc., spoke with Embedded.com about the current edge AI development workflow. He said that much of this development process is handled step by step, from quantization and compilation to runtime selection.
Qualcomm AI Hub provides developers with tools for moving generative AI models onto Qualcomm platforms. Developers can use it to prepare models from open-source repositories for supported devices and evaluate performance on the target hardware.
Qualcomm also offers AI Runtime, which uses optimized libraries and operators to execute models across its compute engines. Sukumar said the company is working toward an agentic layer that can automate more of the quantization, compilation, runtime selection, and deployment process.
An agentic workflow could take instructions such as precompiling a model for a target device, optimizing it for performance, and then coordinating the software tools required to search for that result. Rohini Ramegowda, a firmware engineer at Torus Inc. who works on safety-critical embedded and real-time systems, told Embedded.com that she's already using a narrower version of this workflow in firmware development.
Ramegowda uses an AI agent that reads the requirements she has prepared, employs a MathWorks MATLAB MCP server to build a MATLAB and Simulink model, generates unit tests from an existing template, and runs the simulation. She manually reviews the resulting model against the requirements.
Previously, she had to identify suitable Simulink blocks herself, search MathWorks documentation when necessary, and add them manually. "That used to take weeks," she said. "Now it generates it in hours. But the review part remains the same."
The ability to work across artifacts also helps with diagnosis. In one case, Ramegowda gave an agent a configuration binary, the script that generated it, and the codebase after a device began reporting a huge number of faults. The agent mapped the binary data back to the firmware structures and identified a mismatch within minutes.
These examples show where much of the current acceleration comes from: connecting engineering steps and information that already exists. The challenge becomes difficult when those decisions depend on the behavior and constraints of the physical hardware.
Edge AI agents must understand the hardware
Agentic AI tools are not always optimized to independently navigate through the workflow for an edge-constrained device. These devices have limits on memory, storage, bandwidth, compute capability, and power consumption.
The available processor also determines which numerical formats and model operations can be executed efficiently. For example, a model that works on one system would require different quantization, compilation, and runtime choices on another.
This is important for larger generative AI models. Sukumar explained that moving from a 16-bit model to INT8, INT4, or even lower-precision formats reduces the memory and storage required. Hardware support matters equally, with dedicated neural processing units (NPUs), memory architectures, and power management techniques determining whether the resulting workload can deliver the required performance.
Agentic workflows use this hardware information when deploying or porting a model. Sukumar said an agent would first have to identify characteristics such as the target system-on-chip memory, storage, and bandwidth. It could then retrieve the associated configuration and create binaries optimized for that hardware.
Porting involves more than reproducing the same model binary on another processor. Quantization, graph partitioning, compilation, and runtime configuration must all change to meet the target hardware performance limits.
The difficulty increases closer to the hardware. Ramegowda noted differences in drivers, hardware abstraction layers, linker scripts, and memory configurations between controllers. "I wouldn't think it would be completely autonomous," she said.
Application-level software is easier to move when common interfaces already exist, but adapting the hardware abstraction layer requires more knowledge of the specific controller.
Ramegowda's work with STMicroelectronics' STM32N6 microcontroller shows this in practice. She used an agent to help bring up the board, configure an embedded Rust toolchain, and resolve boot and flashing problems. Even getting to a flashed "Hello World" program took roughly a week with adjustments. More importantly, deciding how NPU inference should share the processor with a deterministic control loop remained a manual architecture decision.
Agents automate more of the path when the hardware is exposed through well-defined tools and interfaces. Hardware-specific architecture is where abstraction begins to fall apart.
Faster AI generation moves the bottleneck to diagnosis
The more agents generate code, models, tests, and configuration files, the engineer must determine that the implementation behaves correctly within the complete embedded system. In some cases, faster generation creates more material that needs to be reviewed.
Ramegowda sees this directly in safety-critical firmware development. When she writes code herself, she already understands the assumptions and architectural decisions behind it. But AI-generated code requires her to reconstruct those assumptions during review.
"The work shifts into review," she said. "There may be much more code to review because every piece of generated code has to be reviewed." This includes checking whether the agent accessed the correct memory region or placed functionality in the appropriate deterministic or nondeterministic layer.
Functional behavior is one part of the verification. Safety-critical software must also follow the required development process and coding rules. Ramegowda said she checks whether generated code conforms to standards such as MISRA and if the required engineering process has been followed.
In certain cases, reviewing and correcting an agent's output takes more time than writing the code manually would have. Static analysis, unit tests, simulation, processor-in-the-loop, and hardware-in-the-loop testing provide additional information. But no single test establishes that generated embedded software is safe under every operating condition.
Edge AI deployment introduces a similar verification problem where a model successfully compiled and running on the target does not show that it is using the hardware efficiently.
Sukumar said developers need an anticipated performance range for the target platform, including measures such as memory and energy consumption.
If the result from an agentic workflow falls outside the range, the deployment or its configuration needs work. Without such a reference, it is difficult to determine whether the results show the hardware's attainable performance.
Agentic AI shortens implementation time, and edge AI deployment accelerates if engineers can also verify the generated output efficiently.
End-to-end autonomy depends on engineering infrastructure
Simply more capable agentic tools will not make embedded development autonomous. The agent also needs access to the critical engineering infrastructure that developers already use to build, diagnose, and validate software.
Sukumar points to compilers, profilers, debuggers, logging systems, documentation, and expected performance data as the foundation for an agentic workflow. If a model fails to compile, for example, only reporting the failure does not help the developer. The agent needs more log history and diagnostic information to identify the cause, locate the documentation, and determine what action to take next.
The longer-term goal is to build an agentic layer that can work across existing engineering tools, including profilers, debuggers, and logging systems, Sukumar said. The agent would use feedback from those tools to diagnose problems, retrieve information, and determine what action to take next.
How much of the embedded development task can be delegated completely depends on the task. Ramegowda, for example, is comfortable assigning agents for test generation, scripts, tooling, documentation, exploratory analysis, and some non-safety-critical application code. Hardware access and system-level safety decisions still require stronger verification.
Sukumar expects human involvement to decrease as the tools mature. "I don't think it's going to be completely zero," he said.
The likely progress is therefore toward greater autonomy, with tools that provide clear context and feedback, while engineers retain control over hardware, hardware behavior, and final verification.
"I'm pretty confident that the infrastructure [including compilers, runtimes, libraries, frameworks, profilers, debuggers, etc.] will continue to improve," Sukumar said.
The opportunity in using agentic AI today may lie in reducing manual work across model conversion, toolchain configuration, hardware bring-up, debugging, optimization, and validation.
The deeper the agents move into the workflow, the more they depend on accurate hardware context, performance targets, and human verification. The important milestone will be a development agent that can take an edge deployment objective, work across the engineering toolchain, and return a result with enough traceability for engineers to determine that it meets the system requirements.
The post How Agentic AI Accelerates Edge AI Software Development appeared first on Embedded.