Software Insights

AI for Embedded Systems: What Agentic Development Requires in Production

Qt Group — Fri, 31 Jul 2026 11:58:56 GMT

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:

A UI- and hardware-aware set of agent skills built for the target platform,
Dedicated, human-in-the-loop reviews so that you don’t rely solely on agents’ judgment.
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.

AI is an Amplifier. But What is it Amplifying?

Julia Probst — Fri, 31 Jul 2026 09:34:15 GMT

The Quiet Gap No Dashboard Shows

Right now, your dashboards probably look great. Output is up. Your team is shipping faster than it used to, and a lot of that speed comes from AI writing code, suggesting tests, and drafting documentation. On paper, this is exactly what you wanted.

But there's something underneath the numbers that no chart really captures. A gap between how fast you're moving and how sure you are about what you're sending out the door. And it widens with every sprint.

When the work is safety-critical, it's the thing about AI worth understanding right now.

How to Reduce AI Token Usage in Enterprise Agentic Development Workflows

peter.schneider@qt.io (Peter Schneider) — Tue, 07 Jul 2026 11:07:20 GMT

Enterprise teams reduce AI token usage in agentic development workflows by combining four practices: structured documentation access that eliminates wasteful web searches, domain-specific skills that prevent costly correction iterations, deterministic tooling for non-reasoning tasks, and intentional model tier selection across workflow phases. Token-efficient AI is not about using AI less — it is about using AI where it pays.

A Pricing Inflection Point That Is Coming

The economics of agentic AI are about to change. GitHub announced that all Copilot plans transitioned to usage-based billing on June 1, 2026 — usage based billing AI now became the default model across the major coding-agent providers. Rather than a flat monthly seat charge covering unlimited usage, every plan will include a monthly allotment of AI credits, with token consumption — including input, output, and cached tokens — counted against that allotment at published rates. Agentic sessions, which have become the default way teams use Copilot, have driven compute costs far beyond what the original fixed-price model was built to support. GitHub is no longer absorbing those costs.

Earlier, Anthropic also announced that starting June 15, 2026, Claude subscriptions would split into interactive and programmatic pools, with agentic and automated usage moving to a separate monthly credit system billed at API rates — then paused that change. For enterprise teams, the practical constraint hasn't loosened: Claude usage remains capped per session, per week, and per model, and heavy agentic workflows still hit those ceilings.

The era of using a standard subscription to run arbitrarily expensive agent sessions is ending. The direction of travel across all major AI providers is the same: costs will increasingly reflect actual token usage, and enterprise teams running agentic development workflows at scale will feel that change directly.

For enterprises building embedded device software with Qt, this is a good time to evaluate.

Agentic development boosts productivity in coding, reviewing, documenting, and testing Qt code. The benefits are clear, so the question isn't whether to use agentic AI. However, each step consumes tokens, and costs add up across a team. The goal is to maximize value from each token. At Qt, we have spent the past several months building and shipping a set of agentic development skills and a documentation service specifically designed to make these workflows leaner, more accurate, and more cost-effective. This article shares what we have learned and what enterprise teams can do right now to control agentic costs without giving up the productivity gains that make agentic development worth adopting in the first place.

How Structured Documentation Access Reduces AI Token Usage

Structured documentation access reduces AI token usage by returning only relevant excerpts from Qt's API reference, rather than full HTML pages containing navigation, sidebars, and unrelated content. A single lookup uses a fraction of the tokens of an equivalent web search while keeping the agent's working context free for actual coding work.

Every time an AI agent searches the web for Qt API information, it receives a full HTML page: navigation menus, cookie banners, related-article sidebars, and forum threads that may predate the Qt version actually in use. A single web search for something as focused as the behavior of Qt's model-view architecture can easily consume thousands of tokens before the agent reads a single word of useful documentation. Multiply that by the dozens of API lookups a typical agentic coding session requires, and the cost compounds quickly.

Qt's documentation MCP, which we published in May 2026 as part of the AI-powered development tools, solves this directly. Rather than fetching full HTML pages, it gives AI agents structured, targeted access to Qt's canonical API reference and guides, returning only relevant excerpts rather than an entire web page. In practice, a single lookup through the service uses a fraction of the tokens of an equivalent web search, keeps the agent's working context free for actual coding work, and eliminates the version-mismatch problem that plagues community answers on Stack Overflow and similar forums.

More than that, every answer comes directly from Qt's maintained documentation rather than from community posts that may have been written for an older Qt version. Agents receive exactly what Qt ships: class references, property tables, signal and slot descriptions, enum values, and officially supported usage examples. In regulated industries, where code traceability matters, this is not just an efficiency win but a guarantee of correctness.

Domain-Specific Skills Eliminate Costly Agentic Iterations

A general-purpose AI agent asked to write Qt UI code will produce something that works at first glance. It will also make a predictable class of avoidable mistakes — mixing layout properties incorrectly, forgetting accessibility requirements, making sub-optimal UI design decisions for the specific target hardware, or producing code that passes review but creates performance problems at runtime. None of these are catastrophic bugs in isolation, but each one requires a follow-up prompt, a correction, and another round of inference — tokens spent fixing errors that domain knowledge would have prevented.

Qt's growing suite of agentic development skills addresses this directly. Skills for UI coding, UI design, code review, documentation, test generation, and performance profiling each encode a curated body of Qt-specific knowledge that the agent applies during the task rather than after the fact. Together, they form a domain-aware agentic development environment for enterprise Qt teams.

The difference in practice is measurable: in the QML100 coding benchmark, Qt's coding skill lifts a frontier model's success rate from 64% to 75% — an 11% improvement that also represents 11% fewer correction cycles and therefore, 11% fewer tokens spent on the coding portion of the workflow. Each avoided correction pass is not just a quality win; it is a direct cost saving under usage-based pricing.

Deterministic Tools Reduce Reliance on Premium AI Models

Many believe agentic AI workflows need the best and most costly models at every step. However, key tasks in software development are often pattern-matching and execution, which are more suited to deterministic tools than AI inference.

Qt's code review skills are a concrete example. The first phase of both the C++ and QML review processes is a single-pass automated linter that runs against all files in scope before the AI agents do anything. This linter mechanically checks more than 100 rule categories, from include ordering and deprecated API usage to error handling patterns and lifecycle correctness, with zero AI inference tokens consumed. Only after this deterministic pass do the specialist analysis agents engage, and by then the surface-level issues have already been resolved. The same logic applies to UI performance profiling, where the performance skill orchestrates Qt's own profiler tooling to capture timing data and feeds the structured output to the AI for interpretation — rather than asking the AI to reason about performance from raw source code.

Test execution follows the same pattern. Rather than asking an AI agent to interpret test output, Qt's test runner skill uses a bundled script to parse standardized test result files, extract pass and fail counts, identify the slowest test cases, and flag likely regressions. The AI receives a clean, structured report and never has to process raw output or reason about test infrastructure.

The practical implication for enterprise teams is that the model tier can be lowered during workflow phases where a deterministic pre-pass has already handled the mechanical work. This is AI cost optimization: a less expensive model consolidates linter output from deterministic tools, a standard model handles report synthesis, and the premium model is reserved for reasoning-intensive tasks such as architectural analysis and cross-file semantic reasoning that genuinely benefit from a larger working context and stronger capabilities.

When the Cost Is Worth Paying

Higher AI token cost is justified when inference replaces a more expensive human activity. For instance, Qt's agentic code review consumes more tokens than simpler tasks but surfaces real issues in minutes, versus two engineers spending several hours per review cycle. AI inference cost must be measured against the human effort being replaced, not in isolation.

Not every step in an agentic development workflow is designed to minimize token usage at all costs. Some tasks are expensive in AI tokens but justify that expense by eliminating an even more costly human activity. For example, code review is resource-intensive in embedded software, especially in regulated industries like automotive, industrial automation, and medical devices, where thorough peer review is mandatory. It requires experienced engineers spending hours reviewing code for safety, threading, and proper Qt usage. The cost is high and increases with team size and release frequency.

Qt's code review skill is expensive in AI tokens relative to simpler agentic tasks. It runs more than 100 automated checks across both C++ and QML code, then launches multiple specialist analysis agents in parallel; each examining a distinct quality dimension such as memory ownership, thread safety, API correctness, error handling, and performance. A review of a non-trivial change across multiple files requires substantial inference.

But consider what it replaces. A thorough multi-agent code review that surfaces genuine issues with concrete mitigation guidance — completed in a few minutes — compares favorably on almost any cost metric against two engineers spending two to four hours doing the same work manually. The AI inference cost for a full review is a small part of a senior engineer’s hourly rate. Unlike a one-time manual review, the agentic review can be run whenever a developer checks a change before committing, not just at formal review gates.

Nevertheless, token cost and human effort are linked; the most token-efficient process isn't always the most cost-effective overall. Teams should measure token efficiency against human effort replaced, not as an absolute metric. A skill may cost more in tokens but save significant engineering time, providing high value. Human code reviews still have costs, but can be more focused and quicker with such skills.

Autonomy vs. Control: Should AI Decide When to Invoke a Skill?

Autonomous skill invocation catches issues a developer might otherwise overlook, but it consumes tokens unpredictably. Human-triggered commands fire skills only when the developer judges them relevant, keeping cost predictable. A hybrid approach — lightweight skills always-on, heavier analysis on explicit command — works well for enterprise teams managing AI token usage at scale.

Every team adopting agentic development faces a choice: should the AI decide when to invoke a skill, or should developers trigger skills explicitly with a command? These approaches have different cost profiles.

Autonomous triggering is compelling because it automatically detects when to run code reviews or design audits, catching issues developers might overlook and streamlining workflows. This makes quality checks more consistent and less reliant on human memory.

The case for human-triggered commands is based on cost control and predictability. An agent deciding to run a multi-agent code review might do so on a work-in-progress change the developer was about to revise, leading to a double spend of tokens and findings, which the developer either ignores or addresses. Human triggering ensures skills activate when the developer finds them relevant, not when an agent pattern matches.

Neither approach is universally correct. Teams with strong token budgets and a preference for automation will lean toward autonomous triggering with sensible guardrails, for example, running a lightweight coding quality skill passively on every code generation, but only running a full multi-phase code review on an explicit commit review request. Teams with strict cost controls or regulatory requirements around when and why automated analysis runs will prefer explicit command triggering with audit trails.

A hybrid model is effective: lightweight, low-token skills run continuously during code generation for immediate benefits at low cost. Heavier tasks, such as code review, test creation, and design token extraction, are triggered by humans. This approach maintains low baseline costs while allowing human oversight over costly analysis steps.

Honest Limitations: What the Current Generation of Skills Cannot Yet Do

Since April 2026, our blog posts on Qt's agentic development skills have consistently documented both limitations and successes.

Output quality varies by model and by how much of the agent's working context is consumed by other tasks. A frontier model running at full attention on a focused task produces substantially better skill output than a smaller model or a frontier model whose context is already occupied by a large codebase. Test generation skills, for example, produce thorough coverage for single-focused components but may generate only boilerplate coverage when invoked across dozens of files at once — the agent's attention is spread too thin to reason carefully about each one.

None of these limitations makes skills less worth using. They do mean that skills work best as one layer of a broader software creation process rather than as a complete replacement for human review, dedicated static analysis tools, and architectural oversight. The teams getting the most value from Qt's agentic skills are those that understand this and integrate them accordingly.

Looking Ahead: Token Economics Will Shape How Skills and Services Are Built

Consumption-based pricing is already reshaping how Qt and the broader ecosystem design agentic tools. Managing agentic AI cost is now a first-class design criterion alongside functional correctness.

Three directions stand out. Tiered model invocation uses a lightweight model for mechanical and formatting work and reserves a more capable one for deep reasoning, cutting inference costs on deterministic tasks without sacrificing quality on analytical ones. Qt's code review skills already point this way: automated linting handles mechanical checks at zero AI inference cost, and only then do specialist analysis agents engage.

Structured access to domain knowledge will extend beyond documentation. Organized access to release notes, breaking-change logs, and platform-compatibility data would let agents answer API stability and migration questions without burning tokens on web searches through outdated community discussions.

Incremental, context-aware analysis is also coming. A review skill that tracks changed files since the last run, rather than re-reviewing the whole codebase, would cut analysis costs by an order of magnitude on projects where most files remain stable between changes.

The bigger shift is cultural. Teams that manage agentic AI cost most effectively aren't using fewer skills; they know which parts of their workflow benefit from AI reasoning and which are better handled by deterministic tooling, structured knowledge services, or human judgment. Token efficiency isn't about doing less with AI. It's about doing the right things with it, and the right things without it.

Explore Qt's AI coding tools and agentic development skills at github.com/TheQtCompanyRnD/agent-skills

The Qt Development plugin, which bundles the skills and Qt's documentation MCP, is available directly from the Claude Marketplace — search for "qt-development".

6 Months from Now: Will Your Codebase Still Match What Was Specified?

Julia Probst — Fri, 19 Jun 2026 10:31:36 GMT

Qt Group Joins the Reynolds & Moore Safety Partner Ecosystem: Building the Verified Foundation for Physical AI

Polina Zyaparova — Wed, 17 Jun 2026 13:12:19 GMT

How to Stop Writing Tests for the Wrong Functions and Start Testing with Ranked Lists by Risk

Polina Zyaparova — Tue, 19 May 2026 13:28:43 GMT

Eighty percent coverage and a green pipeline is a comfortable place to be... Comfortable enough that most teams call it done. The problem is that coverage percentage says nothing about which code was actually exercised, or whether the parts carrying the most risk were ever touched. You can have near-perfect coverage on the most trivial functions in your codebase while the most complex, branch-heavy logic sits completely untested, and the report won't tell you either way.

Qt Open Source and Commercial Licensing Towards CRA in Industrial Automation

Qt Group — Tue, 12 May 2026 11:35:32 GMT

Venla Pouru

Director, Industries, Qt Group

Amit Nainawat

The AI Revolution in Software Development

Dr. Sebastian Krings — Tue, 12 May 2026 10:30:47 GMT

Leveraging AI-powered Static Code Analysis

Artificial intelligence has rapidly evolved from experimental tooling to production-grade infrastructure. AI-powered coding tools like GitHub Copilot, Amazon CodeWhisperer, and Claude have seen widespread adoption across enterprise, startup, and open-source environments. AI models are being integrated into IDEs, CI/CD pipelines, code review processes, and development workflows at an unprecedented scale.

Code Quality: Are LLMs Better Than Humans?

Prof. Dr. Rainer Koschke — Tue, 12 May 2026 10:30:36 GMT

A Critical Look at a Recent Empirical Study on AI-Generated Code

The hype around generative AI and Large Language Models (LLMs) has produced some bold claims: that software developers are becoming obsolete, that AI writes better code than humans, and that the age of the human programmer is drawing to a close. But how much of that is actually backed by empirical evidence? A 2025 study published at the IEEE/ACM International Conference on Mining Software Repositories (MSR), one of the top venues in software engineering research, takes a serious empirical stab at the question.

Embedded UI Design Has a Tool Problem. AI Alone Is Not the Fix.

Antti Kujala — Thu, 30 Apr 2026 11:34:08 GMT

The Bar For Embedded UI Design Has Been Set By The Phone In Your Pocket

Think about the last time you felt genuinely frustrated by a piece of technology. Chances are, it was not your smartphone. It was probably the screen on a piece of industrial equipment, the monitor of a medical device, an in-flight entertainment system, or a car dashboard. Devices that are central to how we work, travel, and make life-critical decisions. And yet their interfaces look and feel like they were designed in a different era.