Qualcomm now owns the road from chip to robot arm

😁 Hello, super humans! If you have ever made a robot arm move from point A to point B without hitting anything, there is a good chance MoveIt did the hard part for you. Yesterday a chip company agreed to buy the team that looks after it. Today we trace what changes when the same owner holds the silicon, the dev board and the motion planner.

📰 Quick Signals

• 🧠 AI: Anthropic says about 950 Claude agents, working through 200,000+ reverse transcriptases in 21 hours, surfaced a previously unknown phage enzyme system it calls ART; its biological function is still unknown.
• 🤖 Robotics: Black Forest Labs released FLUX 3 Action, an open-weight 7B world-action model that predicts the next 32 robot actions plus future camera frames from images, robot state and a text task.
• 💻 Programming: Canonical is moving Ubuntu kernels to weekly releases so CVE fixes reach users faster.
• ⚡ Electronics: Synopsys and TSMC expanded their collaboration to A14-certified EDA flows, agentic AI design automation, CoWoS power delivery, COUPE co-packaged optics, 64G UCIe and HBM4 IP.
• 📡 Telecom: Samsung is the only vendor picked for both KT’s and SK Telecom’s government AI-RAN projects, which start in October with 5G standalone private networks running welding robots at a shipyard and patrol robots at a petrochemical plant.

🔍 The Big Story: Qualcomm now owns the road from chip to robot arm

The hardest part of a manipulation robot is rarely the chip or the model. It is the software in between that turns “grab that part” into a collision-free joint trajectory, and yesterday that layer changed hands.

What happened: On September 23, Qualcomm agreed to acquire PickNik, the Boulder company that grew out of the Willow Garage ROS team and curates the MoveIt manipulation framework. Qualcomm says MoveIt 1 and 2 stay open source under their existing license and community roadmap, and that MoveIt will keep supporting third-party hardware. The price was not disclosed. The first integration target is Arduino’s VENTUNO Q, which opened for pre-orders the same week, and the two companies are demoing PickNik’s commercial MoveIt Pro on VENTUNO Q and Dragonwing at ROSCon Toronto this week.

The details: Look at what now sits under one roof. VENTUNO Q is a “dual-brain” board: a Dragonwing IQ-8275 application processor with up to 40 dense TOPS, 16 GB of LPDDR5 and Ubuntu for perception and planning, next to an STM32H5 microcontroller running the Arduino Core on Zephyr for deterministic motor, CAN-FD and PWM control. Qualcomm bought Arduino in October 2025, so it now owns the board people prototype on, the SoC that goes into production modules from partners such as SECO and Toradex, and the planner that bridges them. That bridge is the interesting bit. A vision-language-action model can tell you where the gripper should go, but it cannot guarantee the arm gets there without clipping a fixture; MoveIt’s job is inverse kinematics, collision checking and time-parameterized trajectories, which then have to be streamed to a real-time controller at a fixed rate.

flowchart TB
    subgraph APP["Dragonwing IQ-8275 (Linux, NPU)"]
        V["Camera + VLM / VLA<br/>'pick the blue part'"] --> G["Grasp pose"]
        G --> M["MoveIt: IK, collision check,<br/>time-scaled trajectory"]
    end
    subgraph RT["STM32H5 (Zephyr, real time)"]
        C["Joint controller<br/>fixed-rate setpoints"] --> D["Motor drivers, CAN-FD, PWM"]
    end
    M -->|"joint setpoints"| C
    D --> A["Robot arm"]
    A -.->|"encoders"| C

The pattern is not unique to Qualcomm. NVIDIA announced earlier this month that it plans to buy Hugging Face and keep it open, and Alphabet’s Intrinsic open-sourced its manipulation core at ROSCon earlier this week. Chip vendors have figured out that developers pick a platform by how fast they get from a demo to a moving arm, and the fastest route runs through open software they did not write themselves.

🗞️ More News

🧠 AI

• Google launched Gemini 3.8 Flash TTS and a cheaper Flash-Lite variant with promptable voice design, 2,000+ production voices, consented voice cloning protected by SynthID, and support for 100+ languages.
• Following up on yesterday’s preview: Sam Altman and Dario Amodei briefed the UN Security Council on AI and international security, with Yoshua Bengio warning of a threat no country can contain alone.
• OpenAI extended its Daybreak cyber-defense program to Ukraine’s government, letting teams use its cyber models to find and test fixes for vulnerabilities in civilian infrastructure.
• Epoch AI estimates the cost of reaching a fixed level of AI performance has fallen about 47% per quarter since 2023, roughly 13x per year.
• Perplexity’s red team ran 108 sandbox-escape attempts across nine models in Firecracker microVMs and found zero VM-to-host escapes, but several models slipped past partial network allowlists using DNS spoofing or shared CDN IPs.
• Apple published LensVLM-9B, which compresses long documents into page images at up to 15x and uses tools to expand only the pages it needs to answer a question.
• NVIDIA open-sourced Nemotron 3 Diarization, a roughly 100M-parameter streaming model that labels who spoke when for up to eight overlapping speakers at 10 ms resolution.

🤖 Robotics

• Helicon raised seed funding to use robots to cut carbon-fiber composite manufacturing lead times from months to weeks.
• Epoch AI’s new Furniture Assembly Benchmark asks models to spot mistakes in half-built flat-pack furniture from the manual and a photo; the best model caught 80% of them.
• Perry Dong and Chelsea Finn argue robotics needs a universal post-training recipe built on value-based reinforcement learning, because real-world samples are expensive and rewards often arrive only at the end of long tasks.

💻 Programming

• Wireshark 4.6.9 fixes 19 security vulnerabilities in its protocol dissectors, so update before you open your next untrusted capture.
• The distributed, offline-first bug tracker git-bug 0.11 adds a full web UI with code browsing and GraphQL improvements.
• Sublime Text 4213 moves its plugin runtime to Python 3.14 and adds file icon themes and Git improvements.
• Strands Harness launched as an Apache 2.0 general-purpose agent harness installable from pip or npm, claiming coding-agent-class benchmark scores at 28% lower token cost.

⚡ Electronics

• Cadence brought UALink, 224G SerDes and wafer-scale design support to TSMC processes, aimed at AI accelerator and HPC designs.
• Mitsubishi Electric laid out a chip-to-grid power strategy for NVIDIA AI factories, covering utility power, conversion, 800 VDC distribution and cooling.
• IonQ will install its Superion 256 trapped-ion quantum computer at NVIDIA’s quantum research center, linked directly to a GB200 NVL72 system over NVQLink.
• Germany’s SPRIND and NADI opened a 40 million euro challenge for teams using AI agents and reinforcement learning to shrink chip design cycles from years to weeks.

📡 Telecom

• T-Mobile applied for FCC experimental licenses to test prototype base stations in the 2.7 GHz and 4.8 GHz bands that the US plans to auction for 6G.
• Australian operator Vocus warned of a subsea capacity crunch, saying some customers want 100x more capacity while cable factories and install ships are booked into the 2030s by hyperscalers.
• Cisco added IEEE 802.1AE MACsec encryption to an Acacia 800ZR coherent pluggable for secure data center links beyond 1,000 km.

👨‍💻 Code Corner

Here is the job MoveIt does, shrunk to its smallest honest form: solve inverse kinematics for a two-link arm, then turn the joint move into fixed-rate setpoints that a real-time controller could stream.

"""The smallest possible 'plan and move' loop: 2-link arm IK + a time-scaled joint trajectory."""
import math

L1, L2 = 0.30, 0.25          # link lengths in metres
VMAX = math.radians(90)      # joint speed limit, rad/s
DT = 0.02                    # 50 Hz control tick, what the real-time MCU would run


def ik(x: float, y: float, elbow_up: bool = True) -> tuple[float, float]:
    """Analytic inverse kinematics for a planar 2-link arm."""
    c2 = (x * x + y * y - L1 * L1 - L2 * L2) / (2 * L1 * L2)
    if abs(c2) > 1:
        raise ValueError(f"({x:.2f}, {y:.2f}) is out of reach")
    q2 = math.acos(c2) * (-1 if elbow_up else 1)
    q1 = math.atan2(y, x) - math.atan2(L2 * math.sin(q2), L1 + L2 * math.cos(q2))
    return q1, q2


def fk(q1: float, q2: float) -> tuple[float, float]:
    return (L1 * math.cos(q1) + L2 * math.cos(q1 + q2),
            L1 * math.sin(q1) + L2 * math.sin(q1 + q2))


def trajectory(start, goal):
    """Synchronised joint move: the slowest joint sets the duration, cosine easing."""
    span = max(abs(g - s) for s, g in zip(start, goal))
    duration = max(math.pi / 2 * span / VMAX, DT)  # cosine peak = pi/2 x average
    steps = int(duration / DT) + 1
    for i in range(steps + 1):
        s = 0.5 - 0.5 * math.cos(math.pi * min(i / steps, 1.0))
        yield [a + s * (b - a) for a, b in zip(start, goal)]


if __name__ == "__main__":
    home = ik(0.40, 0.10)
    pick = ik(0.20, 0.35)
    path = list(trajectory(home, pick))
    print(f"{len(path)} setpoints at {1 / DT:.0f} Hz ({len(path) * DT:.2f} s)")
    for q in path[::10] + [path[-1]]:
        x, y = fk(*q)
        print(f"q=({math.degrees(q[0]):7.2f}, {math.degrees(q[1]):7.2f}) deg -> tool ({x:.3f}, {y:.3f}) m")

Run it and you get 43 setpoints over about 0.86 s, with forward kinematics confirming the tool starts at (0.400, 0.100) m and lands exactly on (0.200, 0.350) m: the Linux side plans, the MCU side just replays numbers on a clock.

🧰 Toolbox

• MoveIt 2: the open-source ROS 2 manipulation framework at the center of today’s Big Story; a good week to star it and read the roadmap.
• Arduino App Lab: the brick-style environment for VENTUNO Q that runs NPU-optimized LLMs, VLMs and detectors, or your own GGUF model from Hugging Face.
• Drop: a rootless, virtualenv-shaped Linux sandbox that hides your real home directory so coding agents can run with aggressive permissions safely.
• Cua: MIT-licensed computer-use infrastructure for macOS, Windows and Linux, with Apple-silicon VMs and a benchmark suite for GUI agents.
• Vercel Sandbox Drives: persistent disks that outlive a sandbox VM, so agent workspaces and model files survive between runs.
• Konveyor: brings Niri-style scrollable column tiling to KDE Plasma 6.4+ on Wayland.

🛠️ Build of the Week (rotating)

DIY ESP32 Audio Spectrum Analyzer: Mirko “mircemk” Pavleski turns an ESP32 display board into a live audio spectrum analyzer with nothing more than a few passives on the input, as Hackaday spotted.

• Difficulty: Beginner
• Parts: CrowPanel 3.5 (ESP32 with a 480×320 touch LCD) or any ESP32 plus display, a few resistors and capacitors to bias and couple the audio into an ADC pin
• Why we like it: it is the friendliest possible hands-on intro to sampling and the FFT, and the same “condition the analog signal, then feed the ADC” step is what every robot sensor input needs too.

📚 From the Blog

• Turning Pixels Into Something the AI Can Eat: episode three of the video analytics series, on the preprocessing that happens before a model ever sees a frame; it is the “camera” box at the top of today’s Big Story diagram.
• Building Your First Neuron From Scratch: weights, bias and activation worked through by hand, from simple learnable transformations up.
• The Network Behind the Cameras: the unglamorous plumbing that moves pixels across a network without choking it.

😀 The Bot Says…

Yeo Kheng Meng loves Windows 98 but owns a 2020 ThinkPad whose only USB controller is modern xHCI, which Windows 98 never supported. So he had LLMs help write the missing drivers, as Hackaday reports. Frontier AI, deployed at scale, to plug in a mouse on an operating system older than most of its training data. We have never been prouder of the species.

---

That’s all for today! Reply and tell us: have you shipped anything on MoveIt, and does a chip vendor owning it make you more or less comfortable?