This article is sponsored by MIPS and was written, edited, and published in alignment with our Emerj sponsored content guidelines. Learn more about our thought leadership and content creation services on our Emerj Media Services page.
One of the most consequential decisions in a physical AI product is made before its software is finished: the compute platform it may depend on for years after launch. Once a vehicle, robot, or factory system is in production, that hardware is costly to change, while its software keeps evolving.
An IEEE Access 2025 review identified two challenges for software-defined vehicles: designing hardware that can accommodate future capabilities and maintaining software over the vehicle’s lifetime. In a 2025 recall notice of 1,212 automated driving systems, the National Highway Traffic Safety Administration reported that Waymo had updated its software to address a risk of collisions with barriers such as chains and gates.
For leaders choosing a compute platform, that means asking which software updates the hardware will need to support after launch and how teams will test and deploy them across products already in service.
In a recent series on the Emerj AI in Business podcast, Senior Editor Yolandi de Weerdt spoke with Sam Grove, Head of Software and Tools at MIPS; Drew Barbier, VP, IP Business Unit at MIPS; and Kyle Larson, VP, AI Enablement and Cloud Services at IDEMIA.
Together, their conversations highlight three practical decisions that can help leaders manage the long-term cost and complexity of physical AI:
- Co-design hardware and software before consolidating systems: Plan software staffing and integration alongside hardware decisions, or savings from fewer components can reappear as software costs.
- Evaluate compute against your actual workload: Define the application’s workload early and use it to guide supplier discussions before the hardware design is finalized.
- Choose platforms for long-term adaptability: Test candidates under real-world operating conditions, and check that the supplier’s ecosystem and roadmap leave room for capabilities the product may need later.
Co-Design Hardware and Software Before Consolidating Systems
Episode: How Leaders Build for the Next Era of Compute – with Sam Grove of MIPS
Guest: Sam Grove, Head of Software and Tools at MIPS
Expertise: Embedded Software, Developer Tools and Toolchains, Open-Source Software, Software Product Management
Brief Recognition: Sam Grove leads the Software and Tools Business Unit at MIPS, a GlobalFoundries company. He previously directed software product management at SiFive, where he oversaw compiler toolchains and development tools. Earlier at Arm, he served as Technical Director, Software and Principal Architect, Device Services. He graduated cum laude from California State University, Long Beach, with a Bachelor of Science in electrical and electronics engineering.
Every additional box or module in a system brings costs to update, support, and maintain over the product’s lifetime, so system builders look to combine functions into fewer, more centralized compute platforms.
Grove warns that integrating previously separate functions can increase software costs enough to erase those savings:
“Worst case scenario, what happens is you just move the cost of the hardware system into the complexity of software and you start building very large software teams, which in many cases can end up being more expensive than the hardware in the supply chain that you just optimized out of.”
— Sam Grove, Head of Software and Tools at MIPS
Grove points out that customers still expect a carmaker to support an eight-year-old vehicle and that large factories may service equipment for decades rather than replace it. Those support obligations can make an architecture costly to maintain long after the original design decision.
Grove traces much of the problem to serial development, in which the hardware is designed first, and software teams start their work only after it is finished. He explains how this sequence can leave software teams without the time or resources to influence the design:
- A team might tell a customer it can deliver what they asked for in nine to 18 months, but software needs can change in that time.
- Software teams start development after the hardware team has finished and moved on, without time or resources set aside for co-design.
- Once products are in use, software teams have to support the existing hardware and triage its issues instead of building new capabilities.
Grove recommends having hardware and software teams work in parallel from the start, with software teams resourced to influence the hardware while the design can still change.
He argues that co-design can help teams keep a product relevant when software requirements change during a long hardware development cycle. If a product took 10 years to build and AI model architectures changed in the meantime, the finished product would no longer be relevant to the market.
He acknowledges that co-design requires investment, whether that means funding a small dedicated team or moving people off future-feature development. He considers that cost worthwhile, because competitors that make the shift will outpace those that do not.
Beyond changing the development process, Grove warns that companies can underestimate the effort needed to retrain their workforce. Around 2010, he helped introduce a new programming language for connected devices that was technically sound by every measure.
Adoption still struggled, however, because developers were comfortable with their existing methods, and retooling the workforce took far more effort than expected. MIPS’ move to RISC-V, an open processor standard, reflects the same long-term thinking, according to Grove. A company that owns a proprietary standard must maintain the software ecosystem around it, often largely on its own.
With an open standard, MIPS can work with customers, competitors, and customers’ customers on the software stack, so the ecosystem no longer depends on a single company whose priorities can change from quarter to quarter.
For leaders evaluating a consolidation or platform change, Grove’s experience suggests four questions to ask before committing to a design:
- Will hardware savings outweigh the added software costs? Compare the savings from removing components with the software staffing, integration, and ongoing support the consolidated design will require.
- How long must the product be supported? Factor the expected support lifetime into architectural decisions.
- Will the change require workforce retraining? Account for the time and resources needed to retrain teams and adapt their tools.
- Can the concept be validated before a full build? Build enough to demonstrate how the system could work, then refine it with customers and partners.
Evaluate Compute Against Your Actual Workload
Episode: Building AI Into Systems That Can’t Afford to Be Late – with Drew Barbier of MIPS
Guest: Drew Barbier, VP, IP Business Unit at MIPS
Expertise: Processor IP, RISC-V Architecture, Semiconductor Product Management, Embedded Systems
Brief Recognition: Drew Barbier leads the IP Business Unit at MIPS, where he previously served as Vice President of Products. Before joining MIPS, he spent nearly seven years at SiFive, including three as Senior Director of Product Management. Earlier in his career, he worked in field applications engineering and technical support at Arm.
Drew Barbier expects edge AI to handle narrower, more specialized tasks than the general-purpose AI running in data centers. In vehicles and industrial machines, where power and thermal budgets are tight, he argues that meaningful performance gains depend on optimizing compute for the specific workload.
For a self-described “hardware guy,” that means reversing the usual starting point:
“With AI, you really start with the software side, with the workload side, and then drive that down and understand the implications of that, not just on the CPU, but on the system as a whole.“
— Drew Barbier, VP of the IP Business Unit at MIPS
The M8500 is a processor design that MIPS licenses to chipmakers, who build it into microcontrollers: the small, dedicated chips that run the electric motors found in vehicles, robots and factory equipment.
Before committing to the design, the MIPS team analyzed representative motor-control workloads on performance models to identify what the processor would need to do. That analysis led to three architectural features, each addressing a specific demand of the workload:
- Real-time multithreading: Faster switching between time-critical tasks.
- Dedicated data ports: Moving data into and out of the core as quickly as possible.
- Built-in trigonometric units: Handling the math that motor-control loops depend on.
Barbier cites two MIPS performance figures for the M8500. One describes how many instructions the processor executes per clock cycle. The other describes performance on selected motor-control algorithms. Barbier does not specify the baseline for either figure in the interview.

Barbier says a chip incorporating the M8500 can perform functions that would otherwise require a microcontroller and a separate accelerator. For buyers, the question is whether that configuration meets their own motor-control requirements.
The example concerns motor control, and Barbier does not identify the algorithms as AI workloads. Few customer chips incorporating the M8500 were available to discuss at the time of the interview, and he gives no production results for the reported gains. For now, Barbier points to deeper discussions with customers about their workloads and how those needs could inform future products.
RISC-V supports this strategy by giving MIPS room to add specialized processor features while maintaining compatibility with the broader software ecosystem customers rely on, Barbier explains.
His recommendations suggest four actions for leaders evaluating compute options:
- Define and constrain the workload: Specify how data flows in and out, required response times and latency, memory needs, and the level of accuracy the application demands.
- Identify system-level bottlenecks: Tell suppliers where software engineers struggle with existing systems, including constraints beyond the processor or the components the supplier is responsible for.
- Engage suppliers early: Bring partners into the discussion with clearly defined workloads and applications, before the design is finalized, since mistakes discovered late are expensive for everyone involved.
- Evaluate the whole system: Compare options based on part count, data movement, power consumption, and application performance.
For Barbier, the starting point for better hardware decisions is understanding the application, not choosing the processor:
“Software first, start from the application and the workload. Constrain that as much as possible. If you engage with your partners earlier with those constrained workloads or applications, you will see much more substantial upside to that engagement than you would otherwise .”
— Drew Barbier, VP, IP Business Unit at MIPS
Choose Platforms for Long-Term Adaptability
Episode: How to Choose a Compute Platform Your Products Won’t Outgrow – with Kyle Larson of IDEMIA
Guest: Kyle Larson, VP, AI Enablement and Cloud Services, IDEMIA
Expertise: Enterprise AI Strategy, Cloud Services, Digital Identity
Brief Recognition: Kyle Larson leads enterprise AI strategy, governance, and cloud services at IDEMIA. He previously led the company’s civil and digital identity business in North America, including mobile driver’s license products, and earlier oversaw global cloud services and customer delivery. At Amazon Web Services, he helped develop offerings for specific industries, including automotive and manufacturing. Earlier in his career, he spent more than 10 years at American Express in roles spanning digital platforms, technology transformation, and service delivery.
Kyle Larson focuses on how teams coordinate hardware and software development to deliver a product they can update and support over time. He saw this challenge while building automotive and manufacturing verticals at Amazon Web Services and sees it now in delivering identity systems to U.S. state governments.
Customers experience the hardware and software as a single product, even when separate teams develop them on different schedules. One early decision is which functions must run on the device and which can run in the cloud. Larson highlights two criteria for making that decision:
- Reliability: If a function must keep working when connectivity drops, as with core driving functions in an autonomous vehicle, it needs to run on the device.
- Latency: If the workload cannot tolerate delays, it also belongs on the device.
When neither condition applies, external compute may be an option, depending on the application’s security, bandwidth, cost and operating requirements.
Larson also stresses that faster software development does not necessarily mean faster customer delivery. AI has accelerated software development at IDEMIA, he says, but deploying a new capability at a state Department of Motor Vehicles office still requires the right cameras, printers and computers to be installed and integrated with the software.
Finished code is only one milestone on the way to a capability customers can use, so rollout plans must account for hardware, software, operational readiness and years of support.
With software evolving much faster than hardware, Larson argues that developer tools need the same priority as the hardware itself, so teams are not left waiting for a physical prototype to find out whether their software works. His approach to testing is pragmatic: pre-release testing will never catch everything, but discovering every problem in production is worse.
Larson uses IDEMIA’s mobile driver’s license work to illustrate how virtual testing can uncover issues before release. App behavior varies across phone models, so the team can use a cloud-based device-testing service to test the app on different devices virtually before release. Some issues may still surface once the app reaches users’ phones.
Virtual testing can give teams earlier feedback. Larson puts responsibility for coordinating hardware and software development with product leaders.
“Never think that there is a world where hardware and software are going to move at the same speed. We are not going to get there. But the responsibility for leaders now is to connect the two through a single product roadmap, early feedback, and shared accountability for the teams. That is ultimately what is going to turn good ideas into great products.”
— Kyle Larson, VP, AI Enablement and Cloud Services at IDEMIA
On compute platform selection, Larson’s first advice is to avoid long-term commitments where possible, using on-demand or shorter-lived options instead. Predicting software requirements seven or eight years ahead is difficult. Where a longer commitment is unavoidable, however, he says leaders must treat the platform choice as a long-term product commitment.
AI-enabled building access control illustrates why: companies do not want to replace cameras and on-site compute frequently, but identity recognition capabilities will continue to evolve. The hardware must therefore leave room for functions that do not yet exist.
When a long-term platform commitment cannot be avoided, Larson recommends working through five questions before making the decision:
- What must the product do, how quickly, and under what conditions? Define the product’s requirements and operating environment before comparing platforms.
- What evidence shows the platform can meet production requirements? Ask suppliers to demonstrate performance on representative workloads and show how the system behaves when connectivity drops or other expected failures occur.
- Does the surrounding ecosystem support the product’s full lifecycle? Assess development tools, software capabilities, engineering skills, and the supplier support available to maintain and evolve the product.
- Can the supplier be a reliable partner over the product’s lifetime? Look beyond the current offering to the supplier’s stability, long-term support commitments, and roadmap visibility.
- Will the platform leave room for capabilities the business may need later? Larson acknowledges that this requires an educated guess, informed by where the business, market, and technology are likely to go.
















