How Small Language Models and task-specific AI can keep vehicle functions responsive and available, even without a permanent Cloud connection

A modern vehicle can offer increasingly natural interaction, but sending every request to a large cloud model is not always the best answer. Connectivity may be limited, response time matters, and many vehicle commands are narrow and clearly defined. For these tasks, a Small Language Model, or SLM, can be the more focused tool.

SLMs share key principles with Large Language Models, but operate with far fewer parameters and can be tailored to a specific purpose. Instead of asking one general-purpose model to handle every interaction, a vehicle can use specialized local models for functions such as HMI configuration, climate settings, seat control, or an offline fallback for a cloud-based assistant.

FEV.io, together with Microsoft and NVIDIA technologies, investigated this approach in a configurable-dashboard showcase. A driver or passenger can use a natural voice command such as “Change the background color to red.” Android Automotive converts speech to text, a locally deployed SLM extracts the intended object, property, and value, and the dashboard application applies the requested change.

Why local, task-specific AI matters

• Availability: selected AI-powered functions can remain usable when the internet connection is limited or unavailable.
• Responsiveness: local inference avoids a cloud round trip for clearly defined commands.
• Efficiency: a compact model can supplement or partially replace cloud inference where a large general-purpose model would be unnecessary
• Control: access to the model and its output process enables task-specific optimization and validation.

Tailoring makes the difference

A compact model is not automatically an automotive solution. It must be guided toward the task and constrained to valid outputs. In the dashboard showcase, FEV combined several methods: task-specific fine-tuning with synthetic data, context manipulation that steers the model toward the required answer, and formal grammar that restricts output to known dashboard objects and properties.

Using Microsoft Phi-4-mini-instruct, synthetic training data curated with NVIDIA NeMo, fine-tuning in Azure Machine Learning, and optimized deployment through NVIDIA AI software, the showcase improved the model’s measured accuracy for key dashboard parameters. The result demonstrates how a specialized local model can translate varied natural-language requests into structured vehicle instructions.

Small Language Models bring focused generative AI to the vehicle edge. A configurable-dashboard showcase demonstrates how model tailoring, structured output, and an embedded architecture turn natural-language commands into reliable vehicle actions.

The right model for the right in-vehicle task

Recent progress in generative artificial intelligence creates new opportunities for vehicle functions and user experiences. Yet deploying a cloud-scale Large Language Model directly in a vehicle is often impractical because embedded platforms have limited compute and memory resources. A permanent internet connection also cannot be assumed for every journey or market.

Small Language Models offer a complementary approach. They follow many of the same principles as larger models but typically contain far fewer parameters. Their more limited general-purpose capability becomes an advantage when the task is clearly defined and the model is deliberately tailored for it.

Rather than routing every request to one large model, a software-defined vehicle can combine different levels of intelligence. A cloud LLM can handle open-ended conversation and broad knowledge. One or more local SLMs can take responsibility for focused vehicle functions, or provide reduced but useful assistant functionality when connectivity is unavailable.

Where embedded Small Language Models create value

For simple vehicle controls, consulting a large cloud model can add infrastructure cost and dependency without adding meaningful value. Small Language Models offer a targeted solution for these edge cases. Climate control, seat adjustment, dashboard configuration, and profile personalization are examples of bounded tasks with known objects, permitted properties, and valid values.

Local execution can improve availability and responsiveness because the request does not need to leave the vehicle. It can also reduce backend demand when selected functions are handled at the edge. Most importantly, a task-specific model gives engineering teams more opportunities to shape and inspect the behavior required for the application.

The broader potential extends beyond HMI configuration. FEV is investigating embedded generative AI for multimodal interaction, automated and autonomous driving, and driver and passenger monitoring. The exact model and architecture must be selected for each use case, particularly when functions affect safety or security.

A showcase: configure the dashboard by speaking naturally

To demonstrate both the potential and the engineering challenges, FEV developed a configurable-dashboard application. The user can modify visual elements through natural language instead of navigating menus. A request may be direct, such as “Please change the color of the clock to green,” or indirect and colloquial, such as referring to the speedometer as “the round thing in the middle showing the speed.”

The application converts each valid request into a structured triplet: object, property, and target value. For the command “Change the background color to red,” the required result is “background, color, red.” Inputs that are related to the dashboard but contain no modification, as well as unrelated statements, must return no action.

This distinction is central to dependable vehicle interaction. The system must not only understand what the user wants. It must also recognize when the user has not issued a valid command.

From speech to a structured vehicle instruction

The showcase uses Android Automotive voice recognition to convert the spoken request into text. The text is distributed to the model-caller application through a Data Distribution Service network. The model caller prompts the locally deployed SLM and publishes the resulting structured instruction back through DDS. The dashboard application then applies the requested design change.

This separation turns the AI model into a modular software service within the in-vehicle architecture. Speech recognition, model inference, communication, and the target application remain distinct components, which supports integration and future replacement or extension of individual modules.

Architecture at a glance

1. User speaks a natural-language request.
2. Android Automotive voice recognition converts speech to text.
3. DDS transports the text to the model caller.
4. The local SLM extracts object, property, and value.
5. DDS publishes the structured instruction.
6. The dashboard application applies the permitted change.

Challenge 1: evaluate language, not just ideal commands

A useful model must handle the variation found in real conversation. FEV therefore created an evaluation canon of 500 prompt-response pairs. It includes direct instructions, indirect phrasing, imprecise and colloquial descriptions, related statements without an action, and completely unrelated sentences.
Each prompt has an expected structured response. This allows the team to evaluate object, property, and value extraction separately, as well as the model’s ability to decide whether an input is relevant to the dashboard at all.

Challenge 2: fine-tune with task-specific synthetic data

To evaluate performance, FEV tested Small Language Models in this environment, specifically using Microsoft Phi-4-mini-instruct with 3.84 billion parameters. Before task-specific modification, the model already achieved 89.0 percent accuracy for objects, 93.6 percent for properties, 84.0 percent for values, and 81.4 percent for instruction relevance on the evaluation canon.

To improve task performance, FEV generated 15.3 thousand synthetic prompt-response pairs with Llama-3.3-70B-Instruct and curated the data using NVIDIA NeMo. The dataset intentionally varied sentence structures, vocabulary, synonyms, colloquial language, and non-actionable inputs. Fine-tuning was performed in Azure Machine Learning using an NVIDIA A100 GPU.

After fine-tuning, Phi-4 achieved 91.2 percent object accuracy, 97.0 percent property accuracy, 91.6 percent value accuracy, and 82.8 percent instruction accuracy. The strongest gains appeared in property and value extraction, the parts of the instruction that determine what should change and how.

Challenge 3: guide the model toward valid answers

Fine-tuning is only one layer of optimization. FEV also employed context manipulation and formal grammar to stabilize output for the specific task.

With context manipulation, the prompt is prefilled to guide the next part of the answer. Instead of asking a model to generate the full triplet at once, the application can introduce wording such as “The driver is talking about the…” to increase the likelihood of selecting the correct dashboard object. Similar guidance can be applied to the property and value.

Formal grammar goes a step further by using prior knowledge of the application. If the dashboard contains a known set of objects, the generation process can restrict or correct token probabilities accordingly. This helps prevent a prominent but irrelevant word from becoming the selected object. The language model remains flexible in understanding the request, while the output space is constrained to instructions the application can execute.

A hybrid edge-cloud architecture delivers the best fit

SLMs are not intended to replace LLMs in every situation. Their strength is specialization. A tailored model can execute a focused task efficiently, whereas a cloud model remains valuable for open-ended requests and broad contextual reasoning.

The practical architecture therefore combines both. When connectivity and the use case support it, the assistant can use a powerful backend LLM. When the network is unavailable, a local SLM can provide selected functions. For bounded commands, local inference can be the primary path from the start.
The result is a model portfolio aligned with the vehicle’s functional architecture: the appropriate intelligence is placed where it creates the most value.

From demonstrator to near-series application

Turning a language model into an automotive function requires more than selecting a model. The work starts with a precise use-case definition and continues through data design, model tailoring, system architecture, embedded integration, performance evaluation, validation, and industrialization.

FEV.io covers this end-to-end development chain. The dashboard configurator shows how the individual disciplines come together in a working in-vehicle application and provides a basis for further customer projects and near-series applications.

The key lesson is straightforward: compact models can deliver meaningful generative AI at the vehicle edge when the task, data, model guidance, compute platform, and integration architecture are designed as one system.

Let us identify the right in-vehicle AI architecture

Whether the starting point is an HMI feature, an offline assistant, a multimodal vehicle service, or a wider GenAI roadmap, FEV can support the path from use-case selection and feasibility assessment to architecture, implementation, validation, and industrialization.

Talk to FEV.io about your embedded GenAI and software-defined vehicle use case: solutions@FEV.io