Arduino UNO Q adds the power of AI to the user-friendly and versatile UNO platform, loved by millions of people.

From blink to think.

From development boards to complete kits: everything you need to get started

Discover what you can create with Arduino

Learn by doing with tutorials, step-by-step guides, and online courses.

Discover the basics of electronics and programming with the Arduino IDE and other platforms.

Tinker and experiment

Join the global maker community share your projects, get inspired, and connect with like-minded creators.

Collaborate on Project Hub, exchange ideas on the Arduino Forum, and turn your vision into reality with the support of the Arduino community.

Share and collaborate

Easily manage and control your connected devices with Arduino Cloud. Seamlessly integrate, monitor, and automate with a user-friendly platform.

Connect, control, and innovate with Arduino Cloud

Endless inspiration from makers like you

Streamline your coding experience with a powerful, intuitive platform for seamless project development.

Arduino IDE

Take your projects to the next level with Arduino Pro range, designed for experts like you!

Are you an expert?

Latest News

Maker

Build a Real-Time LiDAR mapper using Edge Impulse and Arduino UNO Q

Parking Sensor Distance Detector

DuinoScope GIGA R1: Dual-Channel 1Msps Touch Oscilloscope

DIY Synth

Slot Machine Treat Dispenser

Kitchen Safety AI with Arduino UNO Q and OpenClaw

Build a smart mirror with an Arduino UNO Q

Professional grade Smart Lock with ESP32, BLE and Android App Control

Conway's Weather

Automated Irrigation System / Soil Moisture Monitoring System

How to use BACnet MSTP with Arduino UNO R4

Arduino.cc-Blogpost-Cover(1100x600) (4)

Arduino.cc-Blogpost-Featured(385x289) (8)

Arduino.cc-Blogpost-Cover(1100x600) (5)

Arduino.cc-Blogpost-Featured(385x289) (9)

<figure class="wp-block-image size-large"><div class="image-post"><img loading="lazy" decoding="async" width="1024" height="559" src="https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost-Cover1100x600-5-1024x559.jpg" alt="" class="wp-image-42239" srcset="https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost-Cover1100x600-5-1024x559.jpg 1024w, https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost-Cover1100x600-5-300x164.jpg 300w, https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost-Cover1100x600-5-768x419.jpg 768w, https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost-Cover1100x600-5.jpg 1100w" sizes="auto, (max-width: 1024px) 100vw, 1024px" /></div></figure>



The <a href="https://store-usa.arduino.cc/collections/modulino" target="_blank" rel="noreferrer noopener">Modulino family</a> keeps growing, to allow you to easily expand your projects with new tiny modules that bring additional functionalities – in a snap! 



With Modulino Hub, Modulino Extender and Modulino Motors joining the range, you now have no less than 15 easy options to make building your next idea easier and more fun than ever. Think of them as ready-to-deploy functionalities you can add, swap around, and link together to learn, create, or prototype interactive and automated devices.



<h2 class="wp-block-heading">Let’s get to know the three new modules!</h2>



After releasing <a href="https://store.arduino.cc/products/modulino-led-matrix" target="_blank" rel="noreferrer noopener">Modulino LED Matrix</a>, we tackled three pain points the Arduino community has been voicing. 



<ul class="wp-block-list">
<li>Not enough I2C channels? The I2C protocol supports up to 127 devices in theory, but in practice address conflicts between components can become a real bottleneck long before you get there – especially in complex builds where multiple sensors or actuators share the same default address. When your project hits that wall, you can now add a <a href="https://store.arduino.cc/products/modulino-hub" target="_blank" rel="noreferrer noopener">Modulino Hub</a>. By daisy-chaining it to your existing setup, you gain 8 new independent I2C channels, each with its own isolated address space, so you can keep adding components without conflicts and without changing a line of code in your existing logic.</li>



<li>Have a project that’s too large for I2C to handle? I2C is great for short-range communication, but if you have longer distances between devices or larger installations you have two choices: either change protocol and start over, or simply boost the signal. Of course, you had us at simply. Get a <a href="https://store.arduino.cc/products/modulino-extender" target="_blank" rel="noreferrer noopener">Modulino Extender</a>, place it on the I2C bus, and it will amplify the signal to approximately 30 meters (?100 ft) when operating at 100 kHz. No additional libraries needed, because this is a 100% hardware module.</li>



<li>Have a robot or automated mechanism to control? Try <a href="https://store.arduino.cc/products/modulino-motors" target="_blank" rel="noreferrer noopener">Modulino Motors</a> to skip the spaghetti wiring between central controller and devices, and control two DC motors or a single stepper motor with precision. Now you can adjust speed, direction, and position right where the action happens.</li>
</ul>



<h2 class="wp-block-heading">What exactly is Modulino?&nbsp;</h2>



Modulino is our range of plug-and-play smart components designed to take the friction out of building with electronics. Each node connects via Qwiic cable and supports daisy-chaining, so you can combine sensors, actuators, and controllers without redesigning your hardware every time you add something new. A dedicated library – supporting both Arduino language (based on C++) and MicroPython – means the learning curve stays gentle, no matter where you are on your path.



The design philosophy is consistency: every Modulino node shares the same (tiny!) form factor and connection standard, so swapping components between projects is straightforward, and breakout pins give advanced users room to push customization further.&nbsp;



Modulino nodes connect directly to  <a href="https://www.arduino.cc/product-uno-q" target="_blank" rel="noreferrer noopener">Arduino UNO Q</a>, <a href="https://store.arduino.cc/products/nesso-n1" target="_blank" rel="noreferrer noopener">Nesso N1</a>, <a href="https://store.arduino.cc/collections/uno/products/uno-r4-wifi" target="_blank" rel="noreferrer noopener">UNO R4 WiFi</a>, and <a href="https://store.arduino.cc/collections/nano-family" target="_blank" rel="noreferrer noopener">Nano</a> boards, and integrate naturally with <a href="https://cloud.arduino.cc/" target="_blank" rel="noreferrer noopener">Arduino® Cloud</a> tools and the broader Arduino ecosystem – making them equally valuable in a classroom, a maker workshop, or a professional edge IoT prototyping lab. 



<h2 class="wp-block-heading">Get your new Modulino today</h2>



Modulino Hub, Modulino Extender, and Modulino Motors are available today from the <a href="https://store.arduino.cc/" target="_blank" rel="noreferrer noopener">Arduino Store</a> today, as well as through trusted official distributors worldwide. 



Arduino, Modulino, UNO, Nesso, and Nano are trademarks or registered trademarks of Arduino S.r.l.

Three new Arduino® Modulino™ modules are here! Bigger ideas now come with zero added stress

Arduino.cc-Blogpost2-Cover(1100x600)-2

Arduino.cc-Blogpost-Cover(1100x600)-3

Arduino.cc-Blogpost-Featured(385x289)

<figure class="wp-block-image size-large"><div class="image-post"><img loading="lazy" decoding="async" width="1024" height="559" src="https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost-Cover1100x600-3-1-1024x559.jpg" alt="" class="wp-image-42218" srcset="https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost-Cover1100x600-3-1-1024x559.jpg 1024w, https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost-Cover1100x600-3-1-300x164.jpg 300w, https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost-Cover1100x600-3-1-768x419.jpg 768w, https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost-Cover1100x600-3-1.jpg 1100w" sizes="auto, (max-width: 1024px) 100vw, 1024px" /></div></figure>



When talking about large language models (LLMs), people usually imagine a general-purpose assistant: something that can answer questions about weather, politics, software, history, travel, cooking, electronics – and almost any other topic. The model is expected to know a little bit about everything, follow open-ended conversations, and respond to a very broad range of prompts. That’s the experience most of us are used to, since cloud-based AI tools have become so widespread.



Embedded systems work in a much more “narrow” world. A robot does not need to discuss politics, an inspection system does not need to suggest vacation destinations, and a maintenance assistant installed near a machine does not need to explain ancient history. The system needs to understand the device, the task, the possible commands, the local data, and the actions that are safe to suggest or execute. The goal is to give an edge device enough language intelligence to become more useful, more understandable, and more independent from the network.



This is the framework in which we can think about local LLMs on <a href="https://www.arduino.cc/product-uno-q">UNO Q</a>: a practical platform to explore this idea because it brings together a Debian Linux environment and the Arduino® hardware ecosystem. The Linux side can run local AI tools, command-line workflows, Python applications, web services, and inference runtimes. The Arduino side connects that intelligence to sensors, actuators, shields, <a href="https://store.arduino.cc/pages/modulino">Arduino®&nbsp;Modulino™ nodes</a>, and real-world signals. This combination makes it possible to experiment with language models not as isolated chatbots, but as part of real embedded workflows.



The most important question to consider is not how to force a large model to run, but what kind of useful intelligence can live close to the data, close to the device, and close to the physical action?



<h2 class="wp-block-heading">Step 1: choose the right model for your use case</h2>



The edge is where smaller, optimized models become interesting. On the cloud, a large general-purpose model makes sense because it is expected to answer almost anything. On the edge, a model that has been trained, fine-tuned, distilled, or quantized for a specific domain can be more practical. It carries less unnecessary weight, focuses on the type of language the device actually needs, and can be integrated into a controlled application flow.



For example, in robotics the interaction can often be reduced to a limited set of useful instructions: move forward, stop, inspect this object, return to base, report battery level, explain the last error, switch to manual mode. The model can help interpret natural language, but the system should still map that interpretation to a controlled set of valid commands. This makes the behavior easier to test, easier to validate, and easier to trust.



That narrower scope is one of the reasons local LLMs can make sense on embedded platforms.



<h2 class="wp-block-heading">Step 2: understand your memory and storage constraints</h2>



A large language model usually has many parameters, and every parameter represents data that must be stored, loaded, and processed during inference. Model weights are only part of the story. During generation, the runtime also needs working memory for the prompt, the intermediate computation, and the key-value cache used by transformer models to keep track of previous tokens. As the context grows, memory usage grows too.



A 1B-parameter model in 4-bit quantization (such as Llama 3.2 1B Q4) occupies roughly 600–700 MB on disk and requires around 1 GB of RAM at runtime, including the KV cache for a short context window. A 3B model at the same precision pushes past 2 GB. These are numbers that matter on a board with fixed memory and storage, where the model must coexist with the OS, the runtime, and the rest of the application.



Quantization is one of the techniques that makes this more realistic. Instead of storing model weights with high-precision numerical values, a quantized model uses lower-precision representations. This reduces memory usage and can make inference possible on hardware that would otherwise be too constrained. In practical terms, quantization helps move a model from “too large to run locally” towards “small enough to experiment with” –&nbsp;while accepting a trade-off in accuracy, fluency, or speed depending on the model and runtime.



Model distillation is another important concept. In simple terms, distillation is a training approach where a smaller model learns from a larger teacher model. The goal is to keep useful behavior while reducing inference cost and memory footprint. A distilled model will not have the full breadth of the teacher, but it can be much more suitable when the application needs a focused capability on-device.



This example of <a href="https://projecthub.arduino.cc/marc-edgeimpulse/running-local-llms-and-vlms-on-the-arduino-uno-q-with-yzma-74e288">running local LLMs and VLMs on UNO Q with yzma </a>expands the conversation beyond text chat and explores local LLM and VLM workflows using yzma and llama, pointing toward a wider class of edge AI experiments where language models can work together with images, local data, and device context.



<h2 class="wp-block-heading">Step 3: identify where a local LLM adds real value</h2>



Local LLMs become even more useful when they are combined with other edge workflows. OCR is a good example. A camera connected to an UNO Q may extract text from a label, display, document, or machine interface. A compact language model can then summarize that text, classify it, or turn it into a structured response. The model only needs to process the relevant context, which keeps the workflow lighter and more focused.



The same principle applies to an UNO Q that collects logs, sensor readings, error states, or system events. A local model can turn that information into a short human-readable summary directly on the device. For a technician, this can transform raw data into something immediately useful – a compact explanation of the current status or a short description of the last error condition.



<h2 class="wp-block-heading">Step 4: design the architecture and set your boundaries</h2>



One of the most practical ways to think about local LLMs on UNO Q is to treat the model as an occasional reasoning layer. It can be called when language understanding, summarization, or interpretation adds value. Fast control loops, continuous monitoring, and timing-critical actions remain better suited to deterministic software running on the appropriate side of the system.



When working with local LLMs on UNO Q, developers should take into consideration a few practical parameters. Memory usage comes first: the model must fit comfortably together with the runtime and the rest of the application. Response latency comes next: a model that runs may still feel too slow if the use case expects instant answers. Storage should also be planned carefully, because model files and dependencies can be large.



The best entry point is the Arduino Project Hub tutorial <a href="https://projecthub.arduino.cc/robuinlabs/local-llm-ai-chatbot-on-arduino-uno-q-043aa9">Local LLM AI Chatbot on UNO Q</a>, which walks through installing a small LLM and running it offline. It is a useful starting point because it demonstrates the basic shape of a local LLM application



There is also a natural bridge toward local agents. Agentic workflows can move beyond a simple chat interface and start coordinating tools, files, scripts, and actions. On UNO Q, this direction is especially interesting when the agent is treated as an orchestrator on the Linux side. It can inspect logs, prepare files, call scripts, interact with local tools, or help drive development workflows, while the hardware-facing layer keeps direct control over physical I/O.



This kind of setup requires clear boundaries. Giving an agent access to tools means giving it the ability to change things, so the environment should be designed carefully. A dedicated board can be a useful sandbox for this type of experimentation, with limited credentials, limited data access, and a specific set of allowed tools. This makes it possible to explore agentic workflows while keeping the system understandable and controlled.



If you prefer a familiar developer workflow, <a href="https://blogm.tinivelli.com/installing-ollama-on-arduino-uno-q-d7b63a12b1e9">Installing Ollama on Arduino UNO Q</a> covers a practical detail that matters a lot on embedded Linux systems: how to efficiently manage the resources available on the UNO Q to get the most out of it.



<h2 class="wp-block-heading">Step 5: run it, measure it, iterate</h2>



Pick one model, run it on the board, and pay attention to memory usage and response time for your specific prompt. That real-world data will tell you more than any benchmark – and it will give you a much clearer picture of where a local LLM fits in your next embedded project.



Local LLMs on UNO Q always balance power, cost, size, latency, privacy, reliability, and connectivity. The most interesting question is how much useful intelligence can be placed close to the data, the hardware, and the user. Because edge AI is not about more power. It’s about smarter choices. With the right model, the right architecture, and the flexibility of UNO Q, you can test local AI where it matters most: on real hardware, in real projects.



<a href="https://store.arduino.cc/products/uno-q-4gb">Start building with UNO Q</a> and bring your AI ideas closer to the real world. UNO Q is available to order from <a href="http://www.digikey.com/en/product-highlight/a/arduino/uno-q-microcontroller-board">DigiKey</a>, <a href="https://referral.element14.com/OrderCodeView?url=%2Fnew-products%2Fembedded-computers-education-maker-boards%2Farduino-uno-q">Farnell</a>,<a href="https://www.mouser.de/new/arduino/arduino-uno-q-platform/">Mouser</a>, <a href="https://referral.element14.com/OrderCodeView?url=%2Fnew-products%2Fembedded-computers-education-maker-boards%2Farduino-uno-q">Newark</a>, <a href="https://uk.rs-online.com/web/content/m/arduino-unoq-uk">RS Components</a>, and <a href="http://robu.in/">Robu.in</a>; along with our other <a href="https://store.arduino.cc/pages/distributors">authorized distributors and resellers</a>.



Arduino and UNO, and the Arduino logo are trademarks or registered trademarks of Arduino S.r.l.

Running local LLMs on the Arduino® UNO™ Q board: a practical guide

Arduino.cc-Blogpost-Cover(1100x600)

Arduino.cc-Blogpost-Featured(385x289)-2

Arduino.cc-Blogpost-Cover(1100x600)-2

<figure class="wp-block-image size-large"><div class="image-post"><img loading="lazy" decoding="async" width="1024" height="559" src="https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost-Cover1100x600-2-1024x559.jpg" alt="" class="wp-image-42204" srcset="https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost-Cover1100x600-2-1024x559.jpg 1024w, https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost-Cover1100x600-2-300x164.jpg 300w, https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost-Cover1100x600-2-768x419.jpg 768w, https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost-Cover1100x600-2.jpg 1100w" sizes="auto, (max-width: 1024px) 100vw, 1024px" /></div></figure>



Most developers reach for a single-board computer, only to discover they still need a microcontroller for real-time I/O. Then they need eMMC and extra storage. Then a separate AI accelerator. Then comes the custom wiring nightmare just to make everything talk to each other. As your app grows, you find yourself stacking extra boards, external controllers, and shaky communication links. The bill of materials skyrockets, and the integration headaches follow, all just to bridge the gap between Linux computing and real-time control.



<a href="https://www.arduino.cc/product-uno-q">UNO Q</a> starts where that frustration ends. One board. Qualcomm Dragonwing™ QRB2210 Linux-capable processor. Real-time STM32 MCU. Qualcomm® Adreno GPU 3D graphics accelerator. Forget unreliable SD cards with the built-in 32GB eMMC. It’s simple: one board, double the value.



When you can slash system complexity right out of the box, you instantly accelerate your development pipeline and cut down your total deployment costs. No extra fluff, just pure efficiency.



Let’s look under the hood: here are four reasons why UNO Q completely crushes overpriced, complicated hardware with a single, unified platform.



<h2 class="wp-block-heading">#1 Expect more from the right board</h2>



Many modern applications need two very different kinds of computing. On one side, there is the need for AI inference, computer vision, networking, data processing, and cloud connectivity, which all benefit from a Linux environment running on a powerful application processor. On the other side, there are sensors, actuators, motors, industrial signals, and timing-critical tasks that require deterministic real-time control.



Traditionally, developers solve this challenge by combining multiple boards and creating custom communication layers between them. UNO Q puts both worlds on the same board. The Linux MPU handles AI, vision, and data. The STM32 MCU handles sensors, actuators, and timing. They work together –&nbsp;and you don’t even need to design and debug the communication layer.



Of course there is value in having “two boards in one.&#8221; But there is potentially even more value in eliminating external hardware, reducing integration effort, and simplifying system architecture.



This approach is already proving valuable in real-world applications. <a href="https://blog.arduino.cc/2026/06/08/star-stream-is-bringing-f1-level-telemetry-to-every-race-team-and-every-fleet-with-arduino-uno-q/">Star Stream</a>, for example, uses UNO Q to process and analyze high-speed racing telemetry data at the edge. The platform combines Linux-level processing power for data handling and visualization with the deterministic control needed to interact with physical systems in real-time. The result is a solution capable of delivering professional-grade, real-time insights without requiring a complex multi-board architecture: it’s Formula 1 results, without the Formula 1 budget.



<h2 class="wp-block-heading">#2 Lessen the cost with fewer components&nbsp;</h2>



As you move on to more complex endeavors, it’s important to keep the bigger picture in mind: the purchase price of a board is only a small part of a project&#8217;s budget! Additional controllers, interface boards, communication modules, power supplies, and custom integration all contribute to the final cost of a solution.&nbsp;



UNO Q consolidates that BOM. Linux processing, real-time control, high-speed connectivity, and industrial I/O, all on one board. Fewer components means fewer integration points, fewer failure modes, and a bill of materials that doesn&#8217;t keep growing. A lot more applications can be built with fewer components and fewer integration challenges. The result is a lower total cost of ownership (TCO), even before considering maintenance, deployment, and long-term support.



A great, concrete example of this comes from <a href="https://blog.arduino.cc/2026/05/26/zencell-replacing-two-boards-with-one-to-build-a-better-quality-inspection-solution/">ZenCell</a> from PriscoZen, a company developing automated quality inspection systems. By leveraging the dual-brain architecture of UNO Q, they were able to consolidate functionality that would traditionally require multiple devices into a single platform. Fewer boards meant lower BOM cost, fewer integration points, simplified maintenance, and a cleaner overall system design. What’s not to love?



<h2 class="wp-block-heading">#3 Develop AI-native projects with less second guessing&nbsp;</h2>



If you are running an AI model, the real complexity often begins after inference is complete. You need to collect sensor data, make a decision, and trigger a physical response. This needs to be done reliably, in real-time. That requires deterministic control, not a Linux process that can be preempted by the OS. Again, the dual-brain architecture of UNO Q can become particularly valuable from this perspective.



The Linux processor can handle AI models, vision pipelines, orchestration, and high-level decision making. Meanwhile, the microcontroller continues to manage sensors, actuators, and real-time interactions independently. The two processors complement each other naturally, allowing you to build systems that can both understand and react to their environment.



This architecture is especially relevant for applications such as <a href="https://blog.arduino.cc/2026/05/28/industrial-grade-vision-inspection-made-accessible-by-the-arduino-uno-q-board/">visual inspection</a>, predictive maintenance, robotics, smart gateways, and intelligent human-machine interfaces.



The RS DesignSpark team built a PCB inspection 4-part series (you can start with Part 1, <a href="https://www.rs-online.com/designspark/automating-pcb-inspection-with-arduino-uno-q-part-1-introduction">here</a>) that demonstrates this approach in practice. In the project, UNO Q handles image acquisition, machine learning workflows, and application logic while maintaining reliable interaction with the physical inspection environment. Rather than focusing solely on AI performance, the project showcases what is often more important in industrial deployments: connecting intelligence to action. The real kicker? Andrew told us he built the whole system for about $1,700 – with significant savings compared to similar systems starting at $3,000 and going all the way up to $20,000!



<h2 class="wp-block-heading">#4 Build it now, faster, and without friction</h2>



In many professional projects, engineering time can quickly exceed the cost of the hardware itself. Think about it: you need to prepare the environment, install the software stack, connect different tools, move data between systems, and create the infrastructure needed before real application development can even begin.



UNO Q helps reduce friction and speed up the process from the very first step. It ships with onboard eMMC and a preinstalled software environment. No SD card to format. No image to flash. No setup ritual before you can write a line of application code. With onboard eMMC storage and a preinstalled software environment, you can start working without first preparing removable media, flashing an operating system image, or assembling the basic development setup from scratch.&nbsp;



It also matters after deployment. In real-world systems, storage is not just a setup detail: it can affect reliability, maintenance, and uptime. Removable storage can be more exposed to corruption, wear, accidental removal, or failure, which may lead to downtime and additional recovery costs when a system needs to be reinstalled or reconfigured. By relying on onboard eMMC storage, UNO Q offers a more robust foundation for applications that are expected to run continuously and reliably. It also gives you flexibility in how you work with the board: it can be used connected to a PC during development, or run as a full standalone single-board computer (SBC) when the application needs to operate independently.



The advantage of adopting UNO Q becomes particularly clear in <a href="https://blog.arduino.cc/2026/05/28/industrial-grade-vision-inspection-made-accessible-by-the-arduino-uno-q-board/">machine vision and inspection projects</a>, where developers can focus on building the application itself rather than assembling the underlying infrastructure.



As author Andrew Back noted in his final words on <a href="https://www.rs-online.com/designspark/automating-pcb-inspection-with-arduino-uno-q-part-4-creating-the-application">Part 4</a> of the DesignSpark PCB inspection project, “UNO Q, Arduino® App Lab and Edge Impulse together provide a powerful combination, with a clear focus on convenience and enabling the rapid development of sophisticated applications.”



<h2 class="wp-block-heading">Understanding the full value of your hardware</h2>



At the end of the day, the greatest value is found in building a simpler, more efficient, more versatile and scalable system. UNO Q – with its unique combination of Linux computing, real-time control, edge AI readiness, and industrial-grade flexibility – is designed to reduce complexity rather than add it. And for developers building the next generation of intelligent devices, that may be the most valuable feature of all.



The real cost of a system is not what you pay for the board.



It’s the external MCU you didn’t have to buy. The AI HAT you didn’t need. The communication layer you didn’t have to build. The hours you didn’t spend on integration. The maintenance call you avoided, because eMMC doesn’t fail the way SD cards do. Every component you skip is money saved. Every integration point you eliminate is a failure mode removed.



The ultimate system cost isn’t the price of the board, it&#8217;s everything you no longer have to buy, wire, and fix. By packing Linux, edge AI, and real-time control onto a single board, UNO Q slashes your component list, cuts power consumption, and eliminates integration headaches. Zoom in, it does more; zoom out, it saves you more.



Want to dive deep into real-world applications that are proving the value of UNO Q? Read more about:



<ul class="wp-block-list">
<li><a href="https://blog.arduino.cc/2026/06/08/star-stream-is-bringing-f1-level-telemetry-to-every-race-team-and-every-fleet-with-arduino-uno-q/">How Star Stream created a smart, cost-effective solution to process and analyze high-speed racing telemetry data at the edge</a></li>



<li><a href="https://blog.arduino.cc/2026/05/26/zencell-replacing-two-boards-with-one-to-build-a-better-quality-inspection-solution/">How ZenCell replaced two boards with one, to build a better quality inspection system</a></li>



<li><a href="https://www.rs-online.com/designspark/automating-pcb-inspection-with-arduino-uno-q-part-1-introduction">How Andrew Back worked out automated visual inspection of PCBs</a>, leveraging user-friendly training of AI/ML models made available by Edge Impulse</li>
</ul>



UNO Q is available to order from <a href="http://www.digikey.com/en/product-highlight/a/arduino/uno-q-microcontroller-board" target="_blank" rel="noreferrer noopener">DigiKey</a>, <a href="https://referral.element14.com/OrderCodeView?url=%2Fnew-products%2Fembedded-computers-education-maker-boards%2Farduino-uno-q" target="_blank" rel="noreferrer noopener">Farnell</a>, <a href="https://www.mouser.de/new/arduino/arduino-uno-q-platform/" target="_blank" rel="noreferrer noopener">Mouser</a>, <a href="https://referral.element14.com/OrderCodeView?url=%2Fnew-products%2Fembedded-computers-education-maker-boards%2Farduino-uno-q" target="_blank" rel="noreferrer noopener">Newark</a>, <a href="https://uk.rs-online.com/web/content/m/arduino-unoq-uk" target="_blank" rel="noreferrer noopener">RS Components</a>, and <a href="http://robu.in/" target="_blank" rel="noreferrer noopener">Robu.in</a>; along with our other<a href="https://store.arduino.cc/pages/distributors" target="_blank" rel="noreferrer noopener">authorized distributors and resellers</a>.



Qualcomm branded products are products of Qualcomm Technologies, Inc. and/or its subsidiaries. Arduino, UNO, and the Arduino logo are trademarks or registered trademarks of Arduino S.r.l.

Ditch overpriced hardware: 4 ways the Arduino® UNO™ Q board helps you do more for less

Arduino.cc-Blogpost2-Cover(1100x600)

<figure class="wp-block-image size-large"><div class="image-post"><img loading="lazy" decoding="async" width="1024" height="559" src="https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost2-Cover1100x600-1024x559.jpg" alt="" class="wp-image-42186" srcset="https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost2-Cover1100x600-1024x559.jpg 1024w, https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost2-Cover1100x600-300x164.jpg 300w, https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost2-Cover1100x600-768x419.jpg 768w, https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost2-Cover1100x600.jpg 1100w" sizes="auto, (max-width: 1024px) 100vw, 1024px" /></div></figure>



Artificial intelligence has already evolved from simple conversational assistants into autonomous systems capable of interacting with software, hardware, sensors, and even the physical world. The next frontier is not simply “chatting” with AI, but enabling AI agents to observe, reason, decide, and execute actions locally at the edge.



This shift becomes particularly interesting when combined with embedded systems. Why? Because traditionally, embedded development required deterministic programming, fixed automation logic, and carefully predefined behaviors. But now AI systems are capable of dynamically generating code, controlling peripherals, interacting with operating systems, and adapting behavior in real-time. And we see all of this happening in projects built around <a href="https://www.arduino.cc/product-uno-q">the Arduino® UNO™ Q board</a>.



<h2 class="wp-block-heading">“Think local” takes on a whole new meaning</h2>



What makes this especially compelling is that these agents can run locally.



Instead of relying entirely on cloud APIs and remote inference, developers are beginning to deploy autonomous AI systems directly on edge devices – reducing latency, improving privacy, lowering operational costs, and enabling offline functionality. Projects such as <a href="https://www.hackster.io/draider2001/qclaw-a-fully-local-agentic-assistant-on-the-arduino-uno-q-9f4b09">QClaw</a> and the broader <a href="https://www.hackster.io/news/openclaw-can-program-your-arduino-c73287a68858">OpenClaw ecosystem</a> are demonstrating how this model can work on UNO Q.



Our first <a href="https://blog.arduino.cc/2026/05/07/one-board-two-brains-three-ways-a-dual-architecture-board-makes-building-simpler/">dual-brain board</a>&nbsp;is particularly well suited for this new generation of AI-native embedded simple systems because it combines two different computing worlds on the same platform. In simple words, this means you have one board where, on one side, there is a Linux-capable Qualcomm Dragonwing™ QRB2210 processor capable of running Python applications, Docker containers, networking stacks. On the other side, an STM32 microcontroller handles deterministic real-time operations such as GPIO access, peripheral control, and low-level hardware timing. This hybrid architecture allows developers to separate high-level reasoning from low-level execution, effectively creating systems where AI can “think” on Linux while the microcontroller interacts directly with the physical environment.



<h2 class="wp-block-heading">Your word is AI’s command</h2>



One of the most interesting frameworks emerging in this space is OpenClaw. Rather than being a language model itself, OpenClaw acts as an orchestration layer that connects large language models with tools, terminals, filesystems, APIs, and hardware interfaces. As described in the <a href="https://www.qualcomm.com/developer/blog/2026/04/install-openclaw-hermes-agent-qualcomm-arduino-rubik-pi-snapdragon-pcs">OpenClaw installation guide for Qualcomm</a><a href="https://www.arduino.cc/product-uno-q">®</a><a href="https://www.qualcomm.com/developer/blog/2026/04/install-openclaw-hermes-agent-qualcomm-arduino-rubik-pi-snapdragon-pcs">and Arduino</a><a href="https://www.arduino.cc/product-uno-q">®</a><a href="https://www.qualcomm.com/developer/blog/2026/04/install-openclaw-hermes-agent-qualcomm-arduino-rubik-pi-snapdragon-pcs">platforms</a>, the framework enables AI models to move beyond pure text generation and become actionable agents capable of executing commands and interacting with their environment.



This changes the relationship between developers and embedded systems faster than ever. Instead of manually writing every line of code, users can increasingly interact with hardware through natural language. We’ve already showcased a good example of this approach <a href="https://blog.arduino.cc/2026/03/05/radical-accessibility-on-the-arduino-uno-q-board-with-openclaw">here</a>, demonstrating how OpenClaw can run on UNO Q to use conversational prompts to control hardware directly. Rather than opening an IDE and programming peripherals manually, you can ask the agent to blink LEDs, modify animations on the LED matrix, or generate entirely new interactions dynamically.



What makes these demonstrations powerful is the iterative workflow they enable. In one example, the AI agent generated code to display graphics on the LED matrix, uploaded the firmware, and then refined the visual output interactively through additional prompts. The interface to embedded systems effectively becomes conversational. Hardware prototyping starts looking less like firmware engineering and more like collaborative interaction with an intelligent assistant.



<h2 class="wp-block-heading">Fast, private, cheap AI agents? Cutting edge!</h2>



<a href="https://www.hackster.io/draider2001/qclaw-a-fully-local-agentic-assistant-on-the-arduino-uno-q-9f4b09">This concept evolves even further in the QClaw project</a>, where the Arduino UNO Q becomes a fully local agentic assistant. In this architecture, the system is capable not only of generating code, but also of compiling sketches, uploading the compiled code, interacting with local services, and managing workflows autonomously. Within this scenario, the agent orchestrates the full pipeline from intent to execution.



An especially interesting direction is the growing trend toward fully local AI deployments. While many AI systems depend heavily on cloud-hosted models, several developers are exploring combinations of OpenClaw with Ollama and lightweight open-source LLMs to build completely offline agents. The article <a href="https://amannnamm.medium.com/how-to-turn-openclaw-into-a-real-arduino-agent-using-a-free-local-llm-ae5a464a2deb">How to turn OpenClaw into a real Arduino agent using a free local LLM</a> demonstrates how developers can run local inference directly on the device without sending prompts or data to external APIs. In this model, Ollama hosts the local language model while OpenClaw orchestrates tools and actions, allowing UNO Q to function as an autonomous AI node entirely within the local network.



This approach is particularly attractive for edge AI applications because it addresses many of the practical concerns associated with cloud AI. Sensitive data remains local, recurring API costs disappear, internet connectivity becomes optional, and response times improve significantly. Of course, local models are generally smaller and less capable than frontier cloud models, but for many embedded automation tasks the tradeoff is worthwhile. In fact, for hardware-centric workflows, deterministic execution and local responsiveness often matter more than absolute model intelligence.



<h2 class="wp-block-heading">Local AI meets the real world</h2>



The implications become even more interesting when AI agents start interacting with sensors and perception systems. A compelling example comes from <a href="https://bandini.medium.com/dispositivo-para-verificar-hornallas-a-gas-con-ia-arduino-uno-q-openclaw-3d1876bd366d">this AI-powered gas stove monitoring project</a>, where computer vision and local AI reasoning were combined to monitor kitchen burners and detect potentially dangerous situations. Instead of relying on rigid rule-based automation, the AI system interpreted contextual visual information and made decisions dynamically.&nbsp;



This is an important shift because it demonstrates how edge AI agents can combine perception, reasoning, and physical interaction into unified systems capable of operating in real environments.



<h2 class="wp-block-heading">Safety first! Let UNO Q be your “hardware sandbox”</h2>



What emerges from all these projects is a broader transformation in how embedded systems may be designed in the future and how UNO Q allows this shift, acting as an accelerator.&nbsp;



Traditionally, embedded devices were deterministic endpoints executing carefully predefined logic. AI agents introduce adaptability. Developers no longer need to explicitly define every possible branch of execution. Instead, they can define goals, permissions, tools, and constraints, allowing the agent to determine dynamically how tasks should be completed.



This does not eliminate traditional engineering. Rather, it shifts engineering effort toward architecture, orchestration, safety, and supervision. The challenge becomes designing systems where AI agents can act autonomously while remaining constrained, secure, and reliable.



Security is in fact one of the most important considerations in this new paradigm. AI agents often gain access to terminals, filesystems, APIs, and hardware interfaces, which introduces entirely new attack surfaces. One advantage of platforms such as UNO Q is the possibility of creating isolated “<a href="https://www.youtube.com/watch?v=aA1oWSPh41Q">hardware sandboxes</a>” dedicated to agent execution. Instead of granting AI systems unrestricted access to personal laptops or production environments, developers can deploy agents on dedicated edge hardware with limited permissions and compartmentalized resources. This physical separation is one of the most important deployment strategies for safe personal AI agents.



<h2 class="wp-block-heading">The bigger picture</h2>



The broader trend is clear: AI is moving toward the edge, becoming increasingly autonomous, multimodal, and physically interactive. UNO Q plays a relevant role not because it replaces cloud AI, but because it makes AI tangible –&nbsp;empowering developers, makers, researchers, and students to experiment with autonomous embedded intelligence locally, affordably, and safely.&nbsp;



Ready to upgrade from chatbots to autonomous embedded collaborators? <a href="https://store.arduino.cc/products/uno-q-4gb">Get your hands on UNO Q</a> and play an active role in the AI revolution! UNO Q is available to order from <a href="http://www.digikey.com/en/product-highlight/a/arduino/uno-q-microcontroller-board" target="_blank" rel="noreferrer noopener">DigiKey</a>, <a href="https://referral.element14.com/OrderCodeView?url=%2Fnew-products%2Fembedded-computers-education-maker-boards%2Farduino-uno-q" target="_blank" rel="noreferrer noopener">Farnell</a>, <a href="https://www.mouser.de/new/arduino/arduino-uno-q-platform/" target="_blank" rel="noreferrer noopener">Mouser</a>, <a href="https://referral.element14.com/OrderCodeView?url=%2Fnew-products%2Fembedded-computers-education-maker-boards%2Farduino-uno-q" target="_blank" rel="noreferrer noopener">Newark</a>, <a href="https://uk.rs-online.com/web/content/m/arduino-unoq-uk" target="_blank" rel="noreferrer noopener">RS Components</a>, and <a href="http://robu.in/" target="_blank" rel="noreferrer noopener">Robu.in</a>; along with our other <a href="https://store.arduino.cc/pages/distributors" target="_blank" rel="noreferrer noopener">authorized distributors and resellers</a>.



Qualcomm branded products are products of Qualcomm Technologies, Inc. and/or its subsidiaries. Arduino, and UNO, and the Arduino logo are trademarks or registered trademarks of Arduino S.r.l.

Local AI agents on Arduino UNO Q

_DSC2699

_DSC2803 (1)

_DSC2834

_DSC2765 (1)

_DSC2803

_DSC2699 2

Blog Feature Size (4)

_DSC0096

_DSC0117

_DSC2765

_DSC0138

<figure class="wp-block-image size-large"><div class="image-post"><img loading="lazy" decoding="async" width="1024" height="683" src="https://blog.arduino.cc/wp-content/uploads/2026/05/DSC0138-1024x683.jpg" alt="" class="wp-image-42127" srcset="https://blog.arduino.cc/wp-content/uploads/2026/05/DSC0138-1024x683.jpg 1024w, https://blog.arduino.cc/wp-content/uploads/2026/05/DSC0138-300x200.jpg 300w, https://blog.arduino.cc/wp-content/uploads/2026/05/DSC0138-768x512.jpg 768w, https://blog.arduino.cc/wp-content/uploads/2026/05/DSC0138-1536x1024.jpg 1536w" sizes="auto, (max-width: 1024px) 100vw, 1024px" /></div></figure>



Founder George Hammel describes his <a href="https://starstream.pro/">Star Stream</a> engineering team as “a pretty wild group.” A few of them aren’t certified engineers in the traditional sense, but all of them grew up solving problems in motorsports – an environment that rewards fast thinking, creative solutions, and zero tolerance for downtime. That background shows in what they’ve built.



Star Stream is a live video, telemetry, and data streaming service provider, built around Starlink connectivity and designed for the most demanding environments in racing. Their <a href="https://store.starstream.pro/products/streambox-pro-kit">Streambox Pro Kit</a> delivers ultra-low latency video from cockpit to pit wall on circuits and off-road courses alike. But as the demands of professional racing evolved, video alone stopped being enough.



<figure class="wp-block-embed is-type-video is-provider-youtube wp-block-embed-youtube wp-embed-aspect-4-3 wp-has-aspect-ratio"><div class="wp-block-embed__wrapper">
<iframe loading="lazy" title="Star Stream - Empowering the next generation of data-driven racing champions" width="500" height="281" src="https://www.youtube.com/embed/Nxx8zhvHGMI?feature=oembed" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
</div></figure>



After Hammel took part in Arduino Days 2026, we had a chance to dive deeper with him into how Star Stream is meeting challenges and innovating – moving from prototype to track-ready deployment faster than expected – thanks to the Arduino ecosystem’s open-source flexibility.



<h2 class="wp-block-heading">From video to vehicle intelligence</h2>



Teams today want real-time granular telemetry – engine data, GPS, environmental sensors, driver biometrics – delivered fast enough to influence decisions mid-race. That meant Star Stream needed a processing platform that was rugged, versatile, and smart enough to keep up with a vehicle’s own systems.



The answer became the <a href="https://store.starstream.pro/products/telemetrybox">Telemetrybox Pro</a>, their onboard telemetry and biometric system, built around <a href="https://www.arduino.cc/product-uno-q">the Arduino® UNO™ Q board</a>. UNO Q pulls CAN bus frames in real-time, automatically detects and maps signal parameters, and translates raw vehicle data into meaningful telemetry – without any manual configuration from the user. Its machine learning capabilities mean the system doesn’t just read data, it learns from it. As Hammel puts it, “it’s also very smart with the machine learning capabilities that we can program from Star Stream into the device. And now we have the flexibility to make it learn, not just right now, but also well into the future. That gives us scalability.”



In practice, this means teams get real-time telemetry, biometrics, and course diagnostics through Star Stream’s mobile apps and web dashboards – something that until recently was exclusively available with Formula 1 budgets.



<h2 class="wp-block-heading">Built for the track, ready for the road</h2>



Star Stream has already put the Telemetrybox Pro through some of the most extreme conditions in motorsport. At Pikes Peak, where engines struggle with altitude and vehicles are tuned to the limit, a team running Star Stream’s system detected a loss of turbo boost pressure while the car was still climbing. The data reached the pit crew before the driver even reached the summit, giving the mechanics enough time to diagnose the problem, fix it, and send the car out for another run. Without real-time telemetry, Hammel says, the team’s weekend would have been over.



In Baja, where connectivity doesn’t exist until Starlink makes it possible, the stakes are different but just as real. Mid-race, Star Stream’s system flagged a tire losing pressure and a fuel situation developing – the chase crew radioed the driver and co-driver in time to pull over and fix it before the tire went flat. At a recent NORA Rally, a voltage drop was caught early enough that the team switched to a backup alternator before any damage occurred. “We or the chase crew, mechanics, crew chief, can tell what’s going on with the car before the people that are in the car usually know what’s happening,” Hammel explains.



<figure class="wp-block-image size-large"><div class="image-post"><img loading="lazy" decoding="async" width="1024" height="683" src="https://blog.arduino.cc/wp-content/uploads/2026/05/DSC2803-1-1-1024x683.jpg" alt="" class="wp-image-42157" srcset="https://blog.arduino.cc/wp-content/uploads/2026/05/DSC2803-1-1-1024x683.jpg 1024w, https://blog.arduino.cc/wp-content/uploads/2026/05/DSC2803-1-1-300x200.jpg 300w, https://blog.arduino.cc/wp-content/uploads/2026/05/DSC2803-1-1-768x512.jpg 768w, https://blog.arduino.cc/wp-content/uploads/2026/05/DSC2803-1-1-1536x1024.jpg 1536w" sizes="auto, (max-width: 1024px) 100vw, 1024px" /></div></figure>



The Telemetrybox Pro is already in commercial use, not just prototyping. Now, its same technology is being adapted well beyond motorsport: fleet services, automotive mechanics, and contractors – anyone who depends on vehicles to run a business – can use the same real-time vehicle health monitoring to reduce downtime, optimize workflows, and even feed data to insurers to demonstrate safe operation.&nbsp;



Curious to find out more? <a href="https://www.youtube.com/watch?v=1_InodikQd8&amp;t=67s">Watch the full unveil video by Star Stream here</a> and follow Star Stream on <a href="https://www.facebook.com/starstreampro">Facebook</a> or <a href="https://www.instagram.com/starstreampro">Instagram</a>.



Arduino and UNO are trademarks or registered trademarks of Arduino S.r.l

Star Stream is bringing F1-level telemetry to every race team – and every fleet – with Arduino UNO Q

Arduino.cc-Blogpost-Cover(1100x600) (3)

Arduino.cc-Blogpost-Featured(385x289) (6)

<figure class="wp-block-image size-large"><div class="image-post"><img loading="lazy" decoding="async" width="1024" height="559" src="https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost-Cover1100x600-3-1024x559.jpg" alt="" class="wp-image-42173" srcset="https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost-Cover1100x600-3-1024x559.jpg 1024w, https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost-Cover1100x600-3-300x164.jpg 300w, https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost-Cover1100x600-3-768x419.jpg 768w, https://blog.arduino.cc/wp-content/uploads/2026/06/Arduino.cc-Blogpost-Cover1100x600-3.jpg 1100w" sizes="auto, (max-width: 1024px) 100vw, 1024px" /></div></figure>



Edge AI is evolving quickly. It was the end of 2022 when the world saw the first Cloud AI tool available to everyone, accessible through a simple and intuitive chat. In less than four years, models have been refined, distilled, optimized, quantized – at record-breaking speed –&nbsp;to meet the needs of the first generation of edge systems focused mostly on detection and classification: identifying an object, recognizing a keyword, or triggering an action when a predefined event occurs.



The landscape is changing so quickly that the conversation is now already shifting toward something more interesting. Devices are starting to move from simple recognition to local understanding.



So instead of asking, “What is this?&#8221;&#8216; developers are beginning to ask:



<ul class="wp-block-list">
<li>“What is happening here?”</li>



<li>“What does this information mean?”</li>



<li>“What action should the system take next?”</li>
</ul>



This is where local AI agents, LLMs, and intelligent workflows start becoming relevant at the edge.



That does not mean every device suddenly needs to run massive cloud-scale models. In most real-world scenarios, the goal is not running the biggest possible AI model –&nbsp;but running the right intelligence close to where data is generated. This is exactly the space where the <a href="https://www.arduino.cc/product-uno-q">Arduino® </a><a href="https://www.arduino.cc/product-uno-q" target="_blank" rel="noreferrer noopener">UNO</a><a href="https://www.arduino.cc/product-uno-q">™ Q board</a> shows its full potential.



By combining Debian Linux with a real-time STM32 microcontroller, UNO Q creates a hybrid platform where developers can experiment with practical local intelligence while still interacting reliably with sensors, actuators, cameras, industrial signals, and physical systems.



The Linux side can manage higher-level orchestration, local AI frameworks, APIs, dashboards, and model execution. The microcontroller side continues handling deterministic I/O, timing-sensitive interactions, and hardware control. That balance makes it possible to explore a new category of edge applications that don’t immediately depend on cloud infrastructure.



Now, let’s briefly explore three major directions in which UNO Q is contributing to reshaping edge computing. This is the introduction to a series of posts, where we’ll dive into each of these topics in more detail.



<h2 class="wp-block-heading">Building local AI agents on UNO Q</h2>



With the latest developments of agentic AI making headlines in the tech-world news, the next step is creating systems capable of reasoning about tasks and coordinating actions locally.



AI agents are essentially workflows where models interact with tools, hardware, APIs, sensors, or software services to complete specific objectives. On UNO Q, this means creating systems that observe the environment, interpret context, and trigger actions directly on the device.&nbsp;



For example, <a href="https://blog.arduino.cc/2026/03/05/radical-accessibility-on-the-arduino-uno-q-board-with-openclaw/">David Groom ran OpenClaw on UNO Q</a> to access embedded hardware conversationally, with a zero code approach –&nbsp;but an agent could also query and analyze information coming from sensors, summarize machine conditions, read visual states from a camera, or interact with connected services while still keeping the execution flow local. The interesting part is creating focused systems that are useful, understandable, and deployable in real products.



Because UNO Q combines Linux with real-time hardware control, these agents can move beyond chat interfaces and directly interact with the physical world. Interested in finding out more? Stay tuned for the dedicated article in this series.



Start experimenting with radical accessibility, following David’s example <a href="https://blog.arduino.cc/2026/03/05/radical-accessibility-on-the-arduino-uno-q-board-with-openclaw/" target="_blank" rel="noreferrer noopener">here</a>.



<h2 class="wp-block-heading">Running local LLMs on UNO Q</h2>



Local language models are opening the door to a different type of edge interaction.



Instead of sending every request to the cloud, developers can run compact models directly on the device for task-specific workflows such as local assistants, OCR (optical character recognition), status summarization, command parsing, or contextual responses.



There are huge advantages to this in terms of privacy, any time keeping sensitive operational data on-device matters. But the real game-changer in this type of application is the reduced dependency on connectivity paired with improved responsiveness, resulting in systems that continue to operate without skipping a beat even when the network is unavailable.



UNO Q provides a practical platform for these experiments thanks to its <a href="https://docs.arduino.cc/tutorials/uno-q/debian-guide/" target="_blank" rel="noreferrer noopener">Debian Linux environmen</a>t, support for local AI frameworks, and compatibility with optimized inference workflows. Check out the documentation on <a href="https://projecthub.arduino.cc/robuinlabs/local-llm-ai-chatbot-on-arduino-uno-q-043aa9" target="_blank" rel="noreferrer noopener">this Project Hub entry</a> by Robuinlabs to build your own private AI assistant, creating a local LLM chatbot that can run even when the internet is down or connection is not available.



There are, of course, constraints to what models can realistically run on the board, and on the computational power that can be expected from the nimble and cost-effective UNO Q. However, the trade-off may often prove perfectly acceptable for many experiments, prototypes, and a wide range of light applications. You don&#8217;t need a sledgehammer to crack a nut!



We&#8217;ll dive deeper into all of this in the next blog post in this series.



Build your own AI assistant with a local LLM chatbot, thanks to Robuinlab’s tutorial <a href="https://projecthub.arduino.cc/robuinlabs/local-llm-ai-chatbot-on-arduino-uno-q-043aa9" target="_blank" rel="noreferrer noopener">here</a>.



<h2 class="wp-block-heading">Automating AI workflows on UNO Q&nbsp;</h2>



The final step goes beyond single models or isolated agents.



Modern AI systems increasingly rely on workflows composed of multiple stages: capturing information, analyzing context, generating responses, triggering actions, and coordinating software execution. This includes workflows like local audio transcription and object recognition pipelines, multi-source data acquisition and automation systems: a great example of how all of this can fit together is <a href="https://blog.arduino.cc/2026/05/13/nibsy-makes-manual-project-documentation-obsolete/" target="_blank" rel="noreferrer noopener">Kevin McAleer’s “Nibsy” project</a>, an AI agent that watches you work, listens to what you say, and at the end of a session writes the tutorial for you.



In these scenarios, the AI model becomes part of a larger orchestration pipeline rather than a standalone feature.



Using UNO Q is particularly interesting here because it allows developers to combine multiple layers together: Linux applications, Python environments, AI frameworks, cloud-connected services, local APIs, and deterministic microcontroller logic – all running side by side. Some workflows may use local models entirely on-device. Others may combine local execution with cloud-based reasoning depending on latency, privacy, or computational requirements.



The important shift is that UNO Q is no longer limited to simple inference. It enables solutions that coordinate complex operational workflows while remaining closely connected to the physical environment. We’ll see a few inspiring examples of how this can happen in a dedicated blog post.&nbsp;



Explore how AI can automate complex projects in the example documented by Kevin <a href="https://blog.arduino.cc/2026/05/13/nibsy-makes-manual-project-documentation-obsolete/" target="_blank" rel="noreferrer noopener">here</a>.



<h2 class="wp-block-heading">From AI demos to useful edge systems</h2>



One of the biggest misconceptions around AI at the edge is that success is measured by running the largest possible model. In reality, most successful deployments are built around smaller, focused systems designed for specific operational goals –&nbsp;such as:



<ul class="wp-block-list">
<li>Reading text locally from a camera feed</li>



<li>Recognizing gestures without streaming video to the cloud</li>



<li>Summarizing machine states</li>



<li>Interpreting operator commands</li>



<li>Triggering actions from simple contextual understanding</li>



<li>And many other practical examples of intelligence creating real value directly on-device!</li>
</ul>



UNO Q makes experimenting and building applications approachable by combining familiar Linux development with the flexibility of the Arduino ecosystem and real-time hardware interaction. All of it is built leveraging <a href="https://docs.arduino.cc/software/app-lab/" target="_blank" rel="noreferrer noopener">Arduino®&nbsp;App Lab</a> and the <a href="https://docs.arduino.cc/software/app-lab/bricks/about-bricks/" target="_blank" rel="noreferrer noopener">Bricks</a> available there.



Over the next three articles in this series, we’ll explore how local AI agents, LLMs, and complex AI workflows can move from experimentation into practical edge applications running on UNO Q. Are you ready to explore with us?



Arduino, and UNO, and the Arduino logo are trademarks or registered trademarks of Arduino S.r.l.

Beyond Edge AI: bringing local intelligence to Arduino UNO Q

Arduino.cc-Blogpost-Cover(1100x600) (2)

Arduino.cc-Blogpost-Featured(385x289) (5)

<figure class="wp-block-image size-large"><div class="image-post"><img loading="lazy" decoding="async" width="1024" height="559" src="https://blog.arduino.cc/wp-content/uploads/2026/05/Arduino.cc-Blogpost-Cover1100x600-2-1-1024x559.jpg" alt="" class="wp-image-42149" srcset="https://blog.arduino.cc/wp-content/uploads/2026/05/Arduino.cc-Blogpost-Cover1100x600-2-1-1024x559.jpg 1024w, https://blog.arduino.cc/wp-content/uploads/2026/05/Arduino.cc-Blogpost-Cover1100x600-2-1-300x164.jpg 300w, https://blog.arduino.cc/wp-content/uploads/2026/05/Arduino.cc-Blogpost-Cover1100x600-2-1-768x419.jpg 768w, https://blog.arduino.cc/wp-content/uploads/2026/05/Arduino.cc-Blogpost-Cover1100x600-2-1.jpg 1100w" sizes="auto, (max-width: 1024px) 100vw, 1024px" /></div></figure>



Factory lighting can be brutal. A label looks perfect from one angle and unreadable from another. A reflective pouch catches glare. A conveyor casts shadows. A package edge disappears under mixed LED lighting.



Traditional industrial vision systems solve these very real problems, and that’s why they became expensive. However, many inspection tasks don’t require a closed, high-cost smart camera. They just need a reliable prototype path: collect images, train a model, deploy locally, trigger an action, and improve.&nbsp;



On <a href="https://www.arduino.cc/product-uno-q">UNO Q</a>, the Linux side of the board can run the camera pipeline, OpenCV preprocessing, an <a href="https://www.edgeimpulse.com/">Edge Impulse </a>object-detection or classification model, and a local web dashboard. Meanwhile, the MCU side can handle encoder pulses, trigger timing, stack-light outputs, and reject-actuator logic. You can already browse Arduino® <a href="https://projecthub.arduino.cc/?value=UNO+Q&amp;product=d9a35691-8123-4fc3-b2d0-6f16d208dbd8">Project Hub </a>for a variety of practical vision examples that combine UNO Q with Edge Impulse models. We highly recommend the one for <a href="https://projecthub.arduino.cc/lucadilo/a-robot-arm-that-sees-you-built-with-arduino-uno-q-modulino-ledmatrix-2596eb">a robot arm that recognizes people and offers gadgets through intuitive interactions</a>, and the one for <a href="https://projecthub.arduino.cc/marc-edgeimpulse/ocr-on-arduino-uno-q-real-time-text-reading-with-edge-impulse-defec0">OCR (optical character recognition) with a two-stage text detection and recognition pipeline</a> running locally with Arduino® App Lab, plus image classification examples using a USB webcam and Edge Impulse Linux runner.&nbsp;



<h2 class="wp-block-heading">Real-world industrial applications are within reach</h2>



Imagine the following setup: a small conveyor rig with an overhead camera pointed at the product as it passes through an end-of-line station. A quantized model running locally detects pass/fail – checking for the right label, a properly seated connector, a sealed cap, or a surface defect – with inference times under 50 ms. The microprocessor running Debian hosts the dashboard made with Python and logs every result; the MCU triggers the operator’s alert system without waiting for a round trip to the cloud. No frames leave the board, no proprietary software license is required, and the same fixture can be reconfigured for a different product without rearchitecting the system from scratch. Sound like a dream? Nope, it’s real: just check up the setup <a href="https://www.idtsolution.com/">IDT Solution</a> validated in their <a href="https://www.wevolver.com/article/vendor-neutral-automated-optical-inspection-using-edge-ai-and-collaborative-robotics">open-architecture AOI proof of concept for automotive end-of-line inspection</a>.



Want to learn even more? You can also use the UNO Q to run a defect classification model, such as a missing label, wrong color, missing cap, or damaged package. Train the first model in Edge Impulse. Deploy through Arduino App Lab. Run the application as a Debian service or Arduino App Lab app. Use the MCU for deterministic reject timing.



<h2 class="wp-block-heading">UNO Q turns vision into action</h2>



UNO Q has the potential to become the leading SBC for its price and power category, because of the real value it offers.&nbsp;



1. Industrial vision without industrial pricing. Build credible inspection prototypes without committing to proprietary smart-camera systems.



2. Better inspection under real lighting. Use multiple camera views, local preprocessing, and optimized vision models to improve robustness under glare, shadow, and reflective surfaces.



3. AI plus deterministic action. Run inference on Linux; trigger conveyors, lights, and reject mechanisms through the MCU.



<ol class="wp-block-list">
<li></li>
</ol>



The real promise of UNO Q is not just that it can run a vision model. It is that it can turn vision into action.



A traditional camera can capture an image. A cloud model can classify it later. But an industrial inspection system needs more than recognition. It needs timing, reliability, local decision-making, and a way to respond immediately when something is wrong.



<h2 class="wp-block-heading">Edge AI for machine vision: from concept to working prototype</h2>



By combining Debian Linux, Edge Impulse, local AI inference, and deterministic MCU control, developers can build inspection systems that see the product, understand the defect, log the result, and trigger a physical response – all at the edge.



This means a faster path from concept to working prototype. For developers, it means open tools, flexible deployment, and real-world control. For manufacturers, it means machine vision can move beyond expensive, closed systems and become something more accessible, adaptable, and scalable.



That is how industrial vision becomes practical, repeatable, and affordable&nbsp;– and it is exactly the kind of edge AI workflow UNO Q was built to unlock.



Ready to build your first AI camera inspection system? Explore <a href="https://store.arduino.cc/products/uno-q-4gb">UNO Q</a> and start prototyping real-world inspection systems today.



Arduino, UNO and the Arduino logo are trademarks or registered trademarks of Arduino S.r.l.

Industrial-grade vision inspection, made accessible by the Arduino® UNO™ Q board

Blogpost - Cover-4 (1)

Blog Feature Size (3)

<figure class="wp-block-image size-large"><div class="image-post"><img loading="lazy" decoding="async" width="1024" height="558" src="https://blog.arduino.cc/wp-content/uploads/2026/05/Blogpost-Cover-4-1-1024x558.png" alt="" class="wp-image-42123" srcset="https://blog.arduino.cc/wp-content/uploads/2026/05/Blogpost-Cover-4-1-1024x558.png 1024w, https://blog.arduino.cc/wp-content/uploads/2026/05/Blogpost-Cover-4-1-300x164.png 300w, https://blog.arduino.cc/wp-content/uploads/2026/05/Blogpost-Cover-4-1-768x419.png 768w, https://blog.arduino.cc/wp-content/uploads/2026/05/Blogpost-Cover-4-1.png 1201w" sizes="auto, (max-width: 1024px) 100vw, 1024px" /></div></figure>



Carlo Prisco and Fabio Marchese from <a href="https://www.priscozen.net/">PriscoZen</a> had a clear goal from the start: not a technical demo, but a real, working platform that could bring machine control, software logic, and visual quality inspection together in a single compact system. Something they could demonstrate live, evolve over time, and show that industrial automation doesn’t have to mean a traditional PLC in every scenario. The result is ZenCell – and its story is a good example of how innovation, more often than not, emerges through iterations and a progression of improvements, rather than a single eureka moment.&nbsp;



<h2 class="wp-block-heading">Where it started: Arduino®Mega™ board + Raspberry Pi</h2>



The first version of ZenCell was built around a practical architecture: a <a href="https://store.arduino.cc/products/arduino-mega-2560-rev3">Mega 2560 Rev3</a> handling input and output signals, a Raspberry Pi as the central brain coordinating machine logic and the operating cycle, and a Keyence camera for visual inspection. Logic was distributed across two boards, but it worked – well enough that cycle times were in the range of 1.8 to 2.2 seconds.



The team tested the system first at home, validating the overall logic and machine behavior in early-stage conditions. Then they took it further: <a href="https://youtu.be/4d3Z-rfzTMc?si=i1EmL2N7JobZyTtR">ZenCell was integrated alongside a three-axis industrial robot</a> next to a molding press, where it held up just as well. The architecture proved its validity not just as a concept, but in conditions close to real production – and it was open, integrated, and flexible.



<figure class="wp-block-embed is-type-video is-provider-youtube wp-block-embed-youtube wp-embed-aspect-16-9 wp-has-aspect-ratio"><div class="wp-block-embed__wrapper">
<iframe loading="lazy" title="ZenCell Quality Vision: a Modular AI System For Quality Inspection" width="500" height="281" src="https://www.youtube.com/embed/Zo6YJlm9vR0?feature=oembed" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
</div></figure>



<h2 class="wp-block-heading">The shift: from two boards to one</h2>



Once the <a href="https://www.arduino.cc/product-uno-q">Arduino® UNO™ Q board</a> was released, PriscoZen saw an opportunity to greatly improve their solution. Thanks to its dual-brain architecture, UNO Q combines an MPU running Linux with an MCU handling real-time control – exactly the split that Raspberry Pi and Mega were covering separately, now unified on a single compact platform. This allowed Prisco and Marchese to rethink how the system was organized.



In ZenCell V1 – which will début at Maker Faire Caserta 2026 (May 30-31, 2026) – UNO Q is the true engine of the system: hosting the dedicated ZenCell software, managing the cycle logic, coordinating all connected devices, and handling identification peripherals like QR code and barcode readers directly. The result is a cleaner, more centralized architecture, with cycle times brought down to a range of 0.56 to 0.68 seconds.



<h2 class="wp-block-heading">ZenCore: the software layer that ties it all together</h2>



Alongside the hardware evolution, Prisco and Marchese developed ZenCore – the software platform running on ZenCell V1. Accessible through a local web interface with no complex client software required, ZenCore centralizes operational supervision, workflow and recipe management, I/O signal handling, diagnostics, and vision system integration in a single environment.



The long-term vision is a node-based, visual approach to automation logic – connecting devices, commands, states, and sequences in a way that is reusable and adaptable across future applications.



<h2 class="wp-block-heading">The next step for ZenCell</h2>



The roadmap for ZenCell V2 takes the platform further still, with plans to replace the Keyence camera with an open industrial camera and build a proprietary pipeline for image acquisition, dataset development, and defect-recognition model training – all running locally on the next-generation platform.



From a distributed two-board prototype to a centralized system built around a single board’s dual architecture: ZenCell is a clear example of what happens when engineers with the right skills and a concrete vision find the right tools to bring it to life.



Arduino, Mega, and UNO are trademarks of registered trademarks of Arduino S.r.l.

ZenCell: replacing two boards with one, to build a better quality inspection solution

<figure class="wp-block-image size-large"><div class="image-post"><img loading="lazy" decoding="async" width="1024" height="559" src="https://blog.arduino.cc/wp-content/uploads/2026/05/Arduino.cc-Blogpost-Cover1100x600-2-1024x559.jpg" alt="" class="wp-image-42141" srcset="https://blog.arduino.cc/wp-content/uploads/2026/05/Arduino.cc-Blogpost-Cover1100x600-2-1024x559.jpg 1024w, https://blog.arduino.cc/wp-content/uploads/2026/05/Arduino.cc-Blogpost-Cover1100x600-2-300x164.jpg 300w, https://blog.arduino.cc/wp-content/uploads/2026/05/Arduino.cc-Blogpost-Cover1100x600-2-768x419.jpg 768w, https://blog.arduino.cc/wp-content/uploads/2026/05/Arduino.cc-Blogpost-Cover1100x600-2.jpg 1100w" sizes="auto, (max-width: 1024px) 100vw, 1024px" /></div></figure>



Makers and educators, we want to hear from you! Expert or novice, your perspective as an Arduino user matters – and right now, sharing it could win you something pretty special.



We’ve put together a short user survey to better understand how the community uses what we have to offer, what’s working well, and where we can do better. It takes about 10 minutes to complete, it’s open to everyone, and your answers directly inform how we develop our products, tools, and resources going forward.



<h2 class="wp-block-heading">The Arduino Mystery Box Giveaway is here!</h2>



To thank you for your time, we’re running a mystery box giveaway alongside the survey – from May 18 to September 1, 2026. 10 respondents will be randomly selected to receive one of 10 mystery boxes containing Arduino hardware and swag.



It’s quick, it’s open to all levels, and the more voices we hear from, the better we can serve the community. Share the link with your maker friends – the more the merrier!



<a href="https://docs.google.com/forms/d/e/1FAIpQLSeEUo3GSO0RhkUwYE-TzJBAl0a4yLgKErzZ6rVjG5vv0EYgBg/viewform">Take the survey now!</a>



Giveaway Full Official Rules are available <a href="https://content.arduino.cc/assets/Arduino_SurveyGiveaway_TCs.pdf">here</a>. No purchase necessary. Void where prohibited.



The Arduino logo is a trademark or registered trademark of Arduino S.r.l.

Tell us what you think – and enter for a chance to win one of 10 mystery boxes of Arduino gear!

Arduino.cc-Blogpost-Cover(1100x600) (1)

Arduino.cc-Blogpost-Featured(385x289) (3)

<figure class="wp-block-image size-large"><div class="image-post"><img loading="lazy" decoding="async" width="1024" height="559" src="https://blog.arduino.cc/wp-content/uploads/2026/05/Arduino.cc-Blogpost-Cover1100x600-1-1-1024x559.jpg" alt="" class="wp-image-42113" srcset="https://blog.arduino.cc/wp-content/uploads/2026/05/Arduino.cc-Blogpost-Cover1100x600-1-1-1024x559.jpg 1024w, https://blog.arduino.cc/wp-content/uploads/2026/05/Arduino.cc-Blogpost-Cover1100x600-1-1-300x164.jpg 300w, https://blog.arduino.cc/wp-content/uploads/2026/05/Arduino.cc-Blogpost-Cover1100x600-1-1-768x419.jpg 768w, https://blog.arduino.cc/wp-content/uploads/2026/05/Arduino.cc-Blogpost-Cover1100x600-1-1.jpg 1100w" sizes="auto, (max-width: 1024px) 100vw, 1024px" /></div></figure>



We&#8217;re releasing <a href="https://github.com/arduino/ArduinoCore-zephyr/releases/tag/0.55.0">version 0.55.0</a> of the <a href="https://blog.arduino.cc/2025/08/06/updated-arduino-cores-with-zephyros-beta/">Arduino® Core on Zephyr</a> today, and it&#8217;s a meaningful one. This update resolves one of the most common friction points users have reported, adds support for two widely-used libraries, and brings us noticeably closer to our June target for marking this core stable and ending the BETA program. Concurrently, we&#8217;ll begin deprecating the <a href="https://blog.arduino.cc/2024/07/24/the-end-of-mbed-marks-a-new-beginning-for-arduino/">corresponding cores based on mbedOS</a>.



If you&#8217;ve been following the beta, this one is worth updating to.



<h2 class="wp-block-heading">Unified monitor and serial</h2>



The single most requested fix in this cycle was simple and reasonable: <code>Serial.println()</code> should just work.



On previous releases, users running the Arduino® UNO™ Q board had to be intentional about how they routed output — adding <code>#include &lt;Arduino_RouterBridge.h&gt;</code> and being mindful of target differences between IDE 2 and Arduino® App Lab. That friction is gone in 0.55.



We&#8217;ve reworked how outputs are routed and introduced a transparent alias, so printing to <code>Serial</code> or <code>Monitor</code> now delivers the expected result in both Arduino IDE 2 and Arduino App Lab. No bridge header required. If your existing sketch includes <code>Arduino_RouterBridge.h</code>, it&#8217;ll still compile cleanly; it&#8217;s just redundant now.



Print to your monitor without thinking about it.



<h2 class="wp-block-heading">New library support</h2>



Real-Time Clock (RTC): Projects running on Zephyr-supported boards can now use a reliable RTC to track time independently of uptime counters. Sync with a network time server, maintain a running clock with full calendar features, and build time-aware applications with confidence.



CAN Bus: The CAN library opens the door to automotive and industrial applications right from your UNO Q. Add a small CAN transceiver to your setup and you have everything you need to prototype automotive dashboards, robotics control systems, or any device network built on the CAN fieldbus standard.



<h2 class="wp-block-heading">Also in the Zephyr 0.55 release</h2>



<ul class="wp-block-list">
<li>Dynamic Interrupts for UNO Q</li>



<li>shiftIn / shiftOut functions for serial data reading and writing on pins</li>



<li>Zephyr workqueue support for managing low-priority interrupts
<ul class="wp-block-list">
<li>Fixes compilation of libraries that hard-require <code>wiring_private.h</code> and <code>pins_arduino.h</code></li>



<li>Plenty of bug fixes: PWM, WiFi, and more</li>
</ul>
</li>
</ul>



<h2 class="wp-block-heading">Board support</h2>



Nicla Vision joins the supported lineup with this release.&nbsp;



The full compatibility list as of 0.55.0:



<ul class="wp-block-list">
<li>UNO Q</li>



<li>Arduino® Portenta™ H7</li>



<li>Portenta C33</li>



<li>Arduino® Opta™ board</li>



<li>Arduino® Giga™ Display Shield</li>



<li>Arduino® <a href="https://blog.arduino.cc/2026/03/10/your-arduino-nano-matter-board-is-now-a-professional-zephyr-development-platform/">Nano™ Matter</a> board</li>



<li>Nano 33 Bluetooth® LE</li>



<li>Arduino® Nicla™ Sense board</li>



<li>Nicla Vision</li>
</ul>



<h2 class="wp-block-heading">How to get started</h2>



Search for &#8220;zephyr&#8221; in the Arduino IDE Board Manager, install the 0.55.0 release, and you&#8217;re ready to go. Check our full release notes available on <a href="https://github.com/arduino/ArduinoCore-zephyr/releases/tag/0.55.0">GitHub</a> and read our <a href="https://support.arduino.cc/hc/en-us/articles/27251870677916-Migrating-to-Zephyr-core-0-55-0-on-UNO-Q">troubleshooting article</a> for more information.



<h2 class="wp-block-heading">Contribute to the beta program!</h2>



This is your opportunity to shape the future of Arduino development! We welcome feedback, bug reports, and contributions to the core. Visit the <a href="https://github.com/arduino/ArduinoCore-zephyr/issues">GitHub Issues page</a> to report bugs or suggest features. Your feedback will play a critical role in refining this integration and unlocking new possibilities for embedded systems.



Visit the <a href="https://github.com/arduino/ArduinoCore-zephyr">Arduino Core-Zephyr GitHub repository</a> today and start exploring this exciting new platform! Thank you for being a part of the Arduino community.



Thank you for being part of this!



Arduino, UNO, Portenta, Opta, Giga, Nano, and Nicla and the Arduino logo are trademarks or registered trademarks of Arduino S.r.l.

Arduino Core on Zephyr 0.55: Getting ready for the final mile