Skip to content

EMOS v0.7.0 — The Agentic Release

Choose a tag to compare

View all tags
@github-actions github-actions released this 11 May 07:18
v0.7.0
55a552d

This is the biggest EMOS release to date. It brings the entire stack forward a full generation — a brand-new agentic planning layer, graph-backed spatio-temporal memory, live system visualization, process-level self-healing, and a GPU-accelerated navigation engine — alongside a matured, zero-touch CLI and dashboard.

Under the hood, the whole stack moves together: EmbodiedAgents 0.7.3, Kompass 0.5.0, Sugarcoat 0.7.0, and kompass-core 0.8.1.

⭐ Headline features

Cortex — an agentic harness for robots

The marquee addition. Cortex is a planner-executor component you drop on top of the rest of your recipe, and it turns the whole graph into a self-directed agent. It auto-discovers every other component's actions, exposes them to an LLM as callable tools, and runs a two-phase loop: it plans a task into ordered steps, then executes them — dispatching navigation goals, calling a VLM, speaking through TTS — watching feedback and replanning on failure. No event wiring, no hand-tuned prompts, no orchestration glue. Give it a goal in plain language and it figures out the rest.

📖 Cortex reference · Cortex agent tutorial · Cortex driving the full stack

Memory — spatio-temporal graph memory

A new Memory component (built on eMEM) gives robots persistent, queryable recall. Every detection, scene caption, and interoception reading folds into a graph indexed simultaneously by meaning, location, and time. Episodes consolidate into long-term gists; the same object is recognized across sessions; the whole state is a single file that survives reboots. Perception layers and internal-state (interoception) layers are distinguished via is_internal_state, and Cortex consumes Memory's retrieval tools during planning. (Replaces the deprecated MapEncoding component.)

📖 Memory reference · Memory + Cortex tutorial · Spatio-temporal memory recipe

Live System Graph in the dashboard

The Dynamic Web UI now renders a draggable, resizable node-graph of your entire running recipe — components as nodes, topics/events/actions as edges, with a click-through event-detail card. See exactly how your robot is wired, live, while it runs.

📖 Visualizing the System Graph · Dynamic Web UI

Self-healing robots

Two new layers of resilience: process-level auto-respawn via Launcher.on_process_fail() (the launcher relaunches a component whose process actually crashes) and the safe_restart() context manager for atomic in-place reconfigure-and-restart. Layered under the existing component-level fallback system, this keeps long-running deployments alive through model-server outages, segfaults, and OS hiccups with nobody in the loop.

📖 Status & fallbacks · Multiprocessing & fault tolerance

Events from plain Python conditions

You can now build event triggers from any Python method, polled at a configurable check_rate, with no topic or publisher required. Want the robot to react when an internal-state condition goes true — overheating, idle too long, battery low and far from base? It's just a function that returns a bool.

📖 Internal-state events · Events & actions

🧠 Intelligence layer (EmbodiedAgents 0.7.3)

  • Component actions as LLM tools — components expose @component_action/@component_fallback methods that Cortex (or any LLM component) can call as tools, executed through service calls with outputs captured for subsequent steps.
  • VLM actions — the Vision component gains describe and track actions; a new VisionLanguageAction message carries feedback.
  • Async action monitoring — action clients run and are monitored on the main action loop, with helpers to watch and cancel in-flight goals — the foundation for Cortex's long-horizon tasks.
  • System-tool registration — components automatically register their additional ROS entrypoints as tools, with auto-generated descriptions.
  • VLA refinements — the Vision-Language-Action component (shipped in the previous cycle) gained a clearer action name and locking of unimplemented methods.
  • Numerous fixes: STT empty-buffer inference, TTS say abrupt-stop, LLM string-arg tool calling, topic validation now compares ROS 2 message types, callback disambiguation on layer topics.

📖 Intelligence overview · AI components

🧭 Navigation (Kompass 0.5.0)

A big release for navigation, spanning a new controller, GPU-accelerated perception, and tighter integration with the intelligence layer:

  • Pure Pursuit controller — a new full path follower with obstacle avoidance and curvature-based speed regulation, alongside the existing DWA planner.
  • GPU-accelerated local mapping — the pointcloud → laserscan → occupancy-grid pipeline now runs entirely on-device; the 100k-point mapper benchmark clocks ~0.57 ms on an RTX A5000.
  • Smarter DWA — an adaptive prediction horizon that shortens lookahead on tightly curved paths, and an arc-length-based goal cost (CPU and GPU) for more sensible path tracking.
  • Richer goal sources — the Planner now accepts Detections, Trackings, and PointsOfInterest as goal-point inputs (multiple topics allowed), so an intelligence component can hand navigation a structured target instead of a raw pose. Backed by a new on-device depth detector that does 2D→3D bounding-box estimation with outlier rejection.
  • Vision-following refactor — RGB and RGBD followers are now co-equal sibling controllers (ControllersID.VISION_IMG / VISION_DEPTH) selected by algorithm, with the depth follower cleanly separated into a pure depth-tracking controller and new correctness tests.
  • Component introspection — components now describe their available actions, which is what lets Cortex discover and drive the navigation stack.
  • Cleaner architecture under the hood — modularized controller lifecycle/status/obstacle logic, GPU kernel optimizations (trajectory/obstacle tiling, atomics replaced by sub-group reductions, a direct-lidar critical-zone checker), split robot-state/sensor-data updates, quaternion goal-orientation fix, and Rolling/Jazzy compatibility.

⚠️ Breaking: the kompass.launcher module was removed — Launcher now comes from kompass.ros (re-exporting the unified Sugarcoat launcher).

📖 Planning · Vision tracking with depth

🏗️ Foundation layer (Sugarcoat 0.7.0)

  • System Graph visualization (see above), action-server logs streamed into the main logging card, and a geometry display element that auto-renders Point/Pose values when a recipe has no map.
  • Process auto-respawn and safe_restart() (see above).
  • Generic events from Python methods (see above).
  • execute_method service now returns the called method's response — this is what makes Cortex's component-action calls observable.
  • executor_spin_timeout config decouples callback-blocking time from loop_rate.
  • Component introspection + JSON tool descriptions; health monitoring now on for all components by default.

🛠️ EMOS CLI & zero-touch dashboard (0.7.0)

  • Four install modes — container (no ROS needed), native (builds into your ROS 2), licensed (private deployment image), and the new pixi mode (root-less, Docker-less, any Linux distro).
  • Zero-touch dashboard (emos serve) — a browser console with pairing-code + QR onboarding, mDNS discovery (http://emos.local:8765), optional self-signed TLS with fingerprint verification, and emos serve install-service to run it at boot via a hardened systemd unit.
  • emos uninstall — a proper, mode-aware inverse of install, with --keep-data / --keep-config / --remove-image and a path-safety guard.
  • Mode-aware emos update — self-updates the CLI binary from GitHub releases, then updates the install per its mode (pull image / rebuild native / refresh pixi workspace).
  • Recipe lifecycle — emos recipes, emos pull, emos ls, emos info (auto-extracts sensor/topic requirements from recipe.py), emos run (with --rmw and --skip-sensor-check); recipes you drop in ~/emos/recipes/ appear in the dashboard automatically.
  • Device & pairing management — emos config with rotate-pairing (hot-reloads the running daemon), tokens, revoke-token, tls-fingerprint/tls-regenerate, and reset.
  • Mapping tools — emos map record / install-editor / edit.

📖 Installation · CLI reference · Dashboard · Running recipes

🐛 Notable fixes & hardening

  • Dashboard systemd service now reliably comes up after reboot (fixed a self-detection guard that caused the freshly-spawned service to exit, plus boot-time start-limit hardening).
  • Pixi-mode recipe runs from the dashboard now resolve the pixi binary even under the minimal systemd PATH.
  • Custom recipes without a manifest now show Run / Details / Delete buttons in the dashboard.
  • Recipe-catalog requests degrade gracefully when the catalog is unreachable instead of leaking a Go type error.
  • Job event-bus race under concurrent terminal updates resolved via a per-job lifecycle context.
  • Security: CORS locked to local origins, --no-auth refused on non-loopback binds, recipe path-traversal blocked via symlink resolution, recipe markdown sanitized, systemd unit hardened (NoNewPrivileges, ProtectSystem=strict, PrivateTmp), license keys stored 0600.

📚 Documentation

A near-complete docs refresh: new Cortex and Memory reference pages; new hands-on tutorials for Cortex (standalone, with Memory, driving the full navigation stack), generic internal-state events, and the System Graph; a new Running Recipes guide; a fully rewritten installation guide covering all four modes; refreshed vision-tracking, planning, and resilience recipes.

Compatibility: EMOS 0.7.0 pins EmbodiedAgents 0.7.3, Kompass 0.5.0, and Sugarcoat 0.7.0.

📚 Full documentation: https://emos.automatikarobotics.com
💬 Join the community on Discord: https://discord.gg/B9ZU6qjzND

Assets 4
Loading