# ROSA: a natural language agent for ROS1 and ROS2 robots

> ROSA, the Robot Operating System Agent from NASA JPL, wraps an LLM around ROS introspection and tool calls so you can ask a robot what its topics are doing. It is a Python package, and it is opinionated about which LLMs it supports out of the box.

**nasa-jpl/rosa** — ROSA 🤖 is an AI Agent designed to interact with ROS1- and ROS2-based robotics systems using natural language queries. ROSA helps robot developers inspect, diagnose, understand, and operate robots.

- Repository: https://github.com/nasa-jpl/rosa
- Website: https://github.com/nasa-jpl/rosa/wiki
- Stars: 1,645 · Forks: 181
- Language: Python
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/nasa-jpl-rosa

## The problem ROSA targets: ROS introspection has a steep command vocabulary

ROS gives you a large surface of command line tools: rostopic, rosnode, rosservice, rosbag, and their ROS2 equivalents. Answering a question like "which topics have publishers but no subscribers" means knowing which command to run, which flags to pass, and how to read the output. ROSA's stated purpose is to let you ask that question in natural language and have an agent translate it into the right calls and summarize the result. The README frames this as making robotics development "more accessible and efficient," and the demo video shows the agent reasoning about how to draw a five-point star in TurtleSim and then executing the commands. The audience is robot developers working in ROS1 or ROS2 who already have a running system and want a faster diagnostic loop. It is not a control stack, a planner, or a replacement for your existing ROS tooling.

## How ROSA works: a Langchain agent with ROS tools attached

ROSA is built on the Langchain framework, according to the README. You construct it with a model object and a ROS version, then call invoke with a question. The class is imported from the rosa package and instantiated as ROSA(ros_version=1, llm=llm) in the README example, so the ROS version is an explicit constructor argument rather than something detected at runtime. The agent's behavior comes from tools: the README points to a Custom Agents wiki page for "adding tools, and customizing prompts," which implies the default tool set covers ROS introspection and that you extend it for anything domain specific. The package metadata in pyproject.toml lists langchain, langchain-community, langchain-core, and langchain-openai as required dependencies, with langchain-anthropic and langchain-ollama as optional extras. That tells you the OpenAI-compatible path is the default one, and Anthropic or Ollama support requires installing an extra. The Dockerfile shows the same pattern from the other direction: it installs jpl-rosa from PyPI, and separately installs Rust because tiktoken needs to be built, which is the kind of transitive dependency that shapes the install experience.

## Installing jpl-rosa and running a first query

The README gives a two-step quick start. Requirements are Python 3.9 or higher and ROS Noetic or higher. Installation is a single pip command against the jpl-rosa distribution name:

```bash
pip3 install jpl-rosa
```

Note that the import name and the distribution name differ: you install jpl-rosa and import rosa. If you want Anthropic or Ollama models rather than the default OpenAI path, pyproject.toml defines extras, so the install line becomes pip3 install "jpl-rosa[anthropic]" or pip3 install "jpl-rosa[ollama]", or [all] for both. The README does not spell these out; they come from the optional-dependencies table in pyproject.toml.

The README's usage example is short and leaves model construction to you:

```python
from rosa import ROSA

llm = get_your_llm_here()
agent = ROSA(ros_version=1, llm=llm)
agent.invoke("Show me a list of topics that have publishers but no subscribers")
```

The get_your_llm_here() call is a placeholder in the README, not a function in the package. The README redirects you to the Model Configuration wiki page for the real setup, so expect to spend your first ten minutes there rather than in the README. Once the agent is constructed, invoke takes the natural language string and returns the agent's response. If you would rather not wire up a local ROS install, the repository ships a Dockerfile based on osrf/ros:noetic-desktop with turtlesim, and the README points to a TurtleSim Demo Guide in the wiki for running it. The container's shell prompt tells you to run `start streaming:=true` to build and launch the demo, per the Dockerfile's CMD output.

## Limits: beta classifier, external model calls, and a thin README

The first thing to notice is the classifier in pyproject.toml: "Development Status :: 4 - Beta". That is the project's own label, not an outside assessment. The README is a landing page, not a manual; it defers model configuration, custom agents, the TurtleSim demo, and the FAQ to the wiki. If you need to know exactly which ROS commands the default tools invoke, or how the agent handles a command that fails, the README does not say. The second limit is architectural: the agent is built on Langchain and, on the default path, langchain-openai. Queries and the ROS state they gather go to whichever model provider you configure. For a lab robot that is unremarkable; for anything on a network with data handling rules, it is a decision you have to make before you write code. The third is scope. ROSA inspects and operates through the ROS interfaces it has tools for. It is the wrong tool if you want deterministic, auditable command sequences for a safety-relevant motion, because the translation from sentence to command is done by a language model. The README does not document rollback or a dry-run mode for the actions the agent takes.

## Alternatives: scripted ROS CLIs and direct rclpy code

The most direct alternative is not a competing agent but the ROS tooling itself. A shell script that calls rostopic list with the right filters, or a small rclpy node that subscribes to the graph and prints topics with publishers but no subscribers, answers the same question deterministically, runs offline, and does not depend on Langchain version pins. The difference in approach is who does the translation: ROSA asks a model to pick the tool and interpret the output, while a script encodes the decision once and repeats it exactly. The second alternative is writing your own Langchain agent with the ROS tools you care about, which is effectively what the Custom Agents wiki page describes doing inside ROSA. You would lose the packaged tool set and the ROS1/ROS2 abstraction that ROSA's ros_version argument provides, and you would own the prompt engineering. ROSA's value is that this work is already done and packaged on PyPI.

## Maintenance, licence, and what upgrades cost you

The repository is not archived, and the last push was on 2026-03-17, which is the same date as the v1.0.10 release. The release history shows v1.0.8 in April 2025, v1.0.9 in November 2025 labelled "Hotfix: Tiktoken Deps", and v1.0.10 in March 2026. The gap between v1.0.8 and v1.0.9 is roughly seven months, and the v1.0.9 label tells you a dependency problem in tiktoken required an out-of-band fix. That is the shape of the upgrade risk here: the Langchain packages are pinned with compatible-release specifiers (langchain~=0.3.23, langchain-core~=0.3.52, and so on), so a minor bump in the Langchain line can pull in changes ROSA has not been tested against. Budget for pinning your own environment rather than tracking latest. The licence is Apache-2.0, declared both in the LICENSE file and in the pyproject classifier "License :: OSI Approved :: Apache Software License". That permits commercial and closed-source use with the usual notice and patent terms; it is a permissive licence, and the copyright line in setup.py names the Jet Propulsion Laboratory. This is a description of the licence text, not legal advice.

## Conclusion

Adopt ROSA if you are a ROS developer who wants an LLM front end for introspection and simple command sequences, and you are comfortable with the Langchain dependency chain and a beta classifier. Do not adopt it if you need a supported, long-term-maintained interface to a production robot, or if you cannot send robot state to an external model provider. Before you commit, check the wiki's Model Configuration page for your provider, confirm the ROSA class accepts your ros_version, and read the CHANGELOG for the Tiktoken dependency change that landed in v1.0.9.

## FAQ

### What is ROSA and what does it do?

ROSA is the Robot Operating System Agent from NASA JPL, a Python package that lets you interact with ROS1 and ROS2 systems using natural language queries. It is built on Langchain and is intended to help developers inspect, diagnose, understand, and operate robots.

### Does ROSA work with ROS1, ROS2, or both?

Both. The README badges list ROS 1 Noetic and ROS 2 Humble, Iron and Jazzy, and the ROSA constructor takes a ros_version argument, shown as ROSA(ros_version=1, llm=llm) in the README example.

### How do I install ROSA?

Install the jpl-rosa distribution with pip3 install jpl-rosa, then import it as rosa. The README requires Python 3.9 or higher and ROS Noetic or higher.

### Which LLM providers can ROSA use?

langchain-openai is a required dependency, so the OpenAI-compatible path is the default. Anthropic and Ollama support are optional extras in pyproject.toml (langchain-anthropic and langchain-ollama), and the README points to the wiki's Model Configuration page for setup details.

### Do all robots run on ROS?

No. ROSA is limited to ROS1- and ROS2-based systems, as the README states, so a robot without a ROS interface is outside what the agent can inspect or operate.

### Can I try ROSA without a physical robot?

Yes. The repository includes a TurtleSim demo that runs in simulation using Docker, and the README links to a TurtleSim Demo Guide in the wiki for setup and running instructions.

## Sources

- [License: Apache-2.0](https://github.com/nasa-jpl/rosa/blob/main/LICENSE)
- [nasa-jpl/rosa on GitHub](https://github.com/nasa-jpl/rosa)
- [Project website](https://github.com/nasa-jpl/rosa/wiki)
- [README](https://github.com/nasa-jpl/rosa/blob/main/README.md)
- [Releases](https://github.com/nasa-jpl/rosa/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/nasa-jpl-rosa