A hands-on lab in RMPL, the Reactive Model-based Programming Language. You write programs that state goals, tolerate uncertain timing and watch their own progress. An executive then plans, schedules and monitors them.
;; The world decides how long a trip takes, ;; anywhere inside the bounds you declare. (defcp go-to [r :Robot dest lo hi] :effects [(at-end (= r.location dest))] :duration [lo hi :contingent]) (defcp main [] (with-temporal-constraint [0 50] ; deadline (parallel (sequence :slack True (go-to alpha "site-north" 7 18) (sample alpha "site-north") (go-to alpha "rendezvous" 6 16) (initiate-communication alpha bravo)) (sequence :slack True (go-to bravo "site-east" 10 22) ;; ... (initiate-communication bravo alpha)))))
Robots and spacecraft have long been commanded with scripts: fixed sequences of commands that say what to do and when. Scripts are easy to write, but they record neither why each step is there nor how much its timing may vary, so the agent cannot adapt when an action runs long, and cannot tell when something has gone wrong.
This lab introduces participants to the Reactive Model-based Programming Language (RMPL), and through it gives a tour of how several programming paradigms come together to make cognitive agents easier to design, while giving programmers richer ways to specify their behavior. We cover four. Goal-directed programs state what should become true, not how to make it true. Monitorable programs declare conditions and effects, which let the executive detect a failure the moment an assumption breaks. Temporally flexible programs bound uncertain durations and are scheduled online as events unfold. Non-deterministic programs offer alternatives and leave the choice to a planner. Each paradigm hands more of the work from the programmer to the executive, and each rests on algorithms participants will see at work: temporal networks with uncertainty, causal-link monitoring and Conflict-Directed A*.
The lab is half lecture and half coding. The lecture introduces each paradigm and the reasoning behind it. In the hands-on session, participants program a two-robot mission in a Jupyter notebook, starting from a timed command script and adding one paradigm per stage, and watch the Janeway executive plan, schedule and monitor it on simulated robots. Programs are compiled by Tanagra, our RMPL compiler, and checked before they run, so an infeasible program is rejected with the specific constraints that conflict. Everything runs on participants' own laptops in Docker, with no ROS installation or robot hardware, and the same programs run unchanged on physical TurtleBot3 robots.
If you are interested in building cognitive agents, this lab is for you. It suits planning and scheduling researchers who want to see their plans executed, and roboticists who want task-level autonomy without hand-coding sequencing, timeouts and failure checks. It also suits anyone building agents, embodied or driven by large language models, who wants a program representation that an executive can check, schedule and monitor. Participants leave with a working, MIT-licensed RMPL toolchain they can take back to their own research and teaching.
General familiarity with AI and with programming. No background in planning, temporal reasoning, ROS or Lisp is assumed.
| Session | Presenter | Min | Materials |
|---|---|---|---|
| Introduction | Brian Williams | 10 | Slides |
| Self-monitoring programs | Brian Williams | 25 | Slides |
| Programming with flexible time | Brian Williams | 25 | Slides |
| Programs with choices | Brian Williams | 30 | Slides |
| Break | 30 | ||
| Overview of the hands-on lab | Jake Olkin | 15 | Slides |
| Hands-on session: the five-stage mission | Jake Olkin, with Brian Williams | 90 | Notebook |
| Wrap-up and discussion | Brian Williams and Jake Olkin | 15 |
Slides will be linked here after the lab. The notebook is in the lab repository.
The first start downloads about 1 GB, which is slow on conference Wi-Fi. After that the lab runs with no network at all. If you cannot install beforehand, we will have USB drives with the complete lab.
You need a laptop running Windows, macOS or Linux, with git and Docker Desktop (or Docker Engine with the compose plugin) installed. Docker needs about 6 GB of free disk, and the laptop needs 8 GB of RAM. Then:
git clone https://gitlab.com/mit-mers/enterprise/rmpl-lab-2026.git cd rmpl-lab-2026/lab docker compose up
When docker compose ps shows janeway as healthy (about 30 seconds), go to http://localhost:8888/?token=rmpl, open RMPL_Lab.ipynb and run the first cell. If it reports success, you are ready. Stop the lab with Ctrl+C and start it the same way on the day. On Windows, use PowerShell with Docker Desktop's WSL 2 backend.
Janeway is not reachable. Another program uses one of the lab's ports. Run cp .env.example .env, change the host ports in .env to free ones, and run docker compose up again.janeway never becomes healthy. Check docker logs --tail 40 janeway. A missing file usually means Docker ran out of disk: free space with docker builder prune and start again.JUPYTER_PORT=8889 in .env and use http://localhost:8889/?token=rmpl.Brian Williams is Professor of Aeronautics and Astronautics at MIT, where he leads the Model-based Embedded and Robotic Systems group. At NASA Ames he co-invented the Remote Agent model-based autonomy system, which flew on NASA's Deep Space One. He is a Fellow of AAAI.
williams@mit.edu
Jake Olkin is a PhD candidate at MIT in the Model-based Embedded and Robotic Systems group. He builds temporally flexible plan executives, including Janeway, and was a visiting technologist at NASA JPL. He designed and taught the RMPL lab at the 2026 IEEE RAS Summer School on Cognitive Robotics.
jolkin@mit.edu