Skip to content

Dodaios is an open-source agent OS for your desktop: it runs your coding agents, browser and apps by voice or chat, on your own machine. Formerly Personal Jarvis.

ci(agent-runtimes): weekly canary against the latest Hermes and OpenClaw

rubenluetke10-beepc673d8d3b379
diff --git a/.github/workflows/agent-runtimes-canary.yml b/.github/workflows/agent-runtimes-canary.yml
new file mode 100644
index 0000000000..b920ed697f
--- /dev/null
+++ b/.github/workflows/agent-runtimes-canary.yml
@@ -0,0 +1,65 @@
+name: Agent runtimes canary
+# Installs the LATEST Hermes and OpenClaw with their own official installers and
+# drives two turns through Jarvis' runtime drivers against a scripted fake model
+# (scripts/spikes/agent_runtimes_e2e.py, tests/fakes/fake_openai_server.py).
+# Not part of the CI gate: an upstream release that breaks the integration
+# opens an issue here before a person runs into it. See docs/agent-runtimes.md.
+on:
+ schedule:
+ - cron: '17 5 * * 1'
+ workflow_dispatch:
+permissions:
+ contents: read
+jobs:
+ canary:
+ strategy:
+ fail-fast: false
+ matrix:
+ os: [ubuntu-latest, windows-latest, macos-latest]
+ runtime: [hermes, openclaw]
+ runs-on: ${{ matrix.os }}
+ timeout-minutes: 45
+ steps:
+ - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+ with:
+ persist-credentials: false
+ - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97
+ with:
+ python-version: '3.12'
+ - name: Install the base app
+ run: python scripts/pip_install.py -e "."
+ - name: Install Hermes (official installer, Linux/macOS)
+ if: matrix.runtime == 'hermes' && runner.os != 'Windows'
+ run: |
+ curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash -s -- --skip-setup --non-interactive --skip-browser
+ echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+ - name: Install Hermes (official installer, Windows)
+ if: matrix.runtime == 'hermes' && runner.os == 'Windows'
+ shell: pwsh
+ run: |
+ & ([scriptblock]::Create((irm https://hermes-agent.nousresearch.com/install.ps1))) -SkipSetup -NonInteractive
+ "$env:LOCALAPPDATA\hermes\bin" | Out-File -FilePath $env:GITHUB_PATH -Append -Encoding utf8
+ - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0
+ if: matrix.runtime == 'openclaw'
+ with:
+ node-version: '24'
+ - name: Install OpenClaw (latest)
+ if: matrix.runtime == 'openclaw'
+ run: npm install -g openclaw@latest
+ - name: Drive two turns through the Jarvis driver
+ run: python scripts/spikes/agent_runtimes_e2e.py ${{ matrix.runtime }}
+ report:
+ needs: canary
+ if: failure() && github.event_name == 'schedule'
+ runs-on: ubuntu-latest
+ permissions:
+ issues: write
+ steps:
+ - name: Open an issue for the broken runtime integration
+ env:
+ GH_TOKEN: ${{ github.token }}
+ RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+ run: |
+ gh issue create --repo "$GITHUB_REPOSITORY" \
+ --title "Agent runtimes canary failed" \
+ --body "The weekly canary could not drive the latest Hermes or OpenClaw release through Jarvis' runtime drivers. Run: $RUN_URL (see docs/agent-runtimes.md)."
diff --git a/docs/os-parity.md b/docs/os-parity.md
index 071fa3a734..4d5321ba42 100644
--- a/docs/os-parity.md
+++ b/docs/os-parity.md
@@ -1207,6 +1207,7 @@ build: the first release with this code needs one live update per OS.
| P-41 | Medium | Dictation final pass | The dictation lane reads its final pass on the machine, in front of any configured cloud provider, through the same out-of-process worker the live preview uses (`jarvis.dictation.preview_worker`) with a stronger checkpoint (`[dictation].local_model`, default `large-v3-turbo`, `int8_float16`, beam 5). 2026-09-02 forensics: 220 of 220 dictations had run on a cloud recognizer the settings did not name, because the VOICE lane had been moved there to keep CUDA out of the desktop process, and the dictation lane inherited the move — round-trips as lag, near-empty answers on 25 s windows as "truncated window" repairs. The provider declines itself with a CROSSABLE failure (HTTP-503-shaped, `LocalEngineUnavailable`) so the configured provider is one step behind on every press and never a restart away: too little free accelerator memory (`[dictation].local_min_free_gb`, default 1.5; an UNKNOWN reading never blocks), a worker that only comes up on the CPU, a missing local runtime, a worker that died. A call abandoned at its ceiling leaves its answer in the pipe, so the next call kills that worker instead of reading it (AP-24) | `jarvis/dictation/local_final.py::LocalFinalSTT`, `jarvis/speech/pipeline.py::_dictation_local_final`, `_dictation_stt`, `jarvis/dictation/local_preview.py::_spawn_worker_model` (`compute`), `preview_worker.py` (`beam_size`, `segments`), `jarvis/hardware/detection.py::free_accelerator_gb` | Windows/Linux with an NVIDIA card and the local runtime: the final pass runs locally when ≥ 1.5 GB is free, else the cloud chain. macOS: no NVIDIA reading → the memory gate passes as unknown, and the worker's own device ladder decides; a CPU-only worker is declined for the final pass (a beam decode of a 25 s window on a CPU is slower than the cloud it would replace), so Apple Silicon stays on the configured provider until a Metal-backed runtime exists. Headless `python:3.11-slim` (no `faster-whisper`): the provider is never built and the chain is exactly what it was. Switch: `[dictation].local_engine = false`. Guards: `tests/unit/dictation/test_local_final.py`, `test_preview_worker.py` |
| P-41 | Low | CLI install / connect terminal | Pressing **Install** or **Connect** in the CLI section opens a REAL terminal window and runs the command there, because an interactive OAuth login belongs in a shell the user can see and type into. That spawn was Windows-only until 2026-08-28 (`wt` -> `pwsh` -> `powershell`), so on macOS and Linux the two buttons reported "No external terminal available" and no CLI could be installed from the app at all. macOS now goes through `osascript` to Terminal.app, Linux through the first of seven emulators that exists (Debian's `x-terminal-emulator` alternative first, so the user's own default wins), and the window is held open afterwards the way `-NoExit` holds it on Windows. One install click now carries all the way to signed in: the terminal runs the install, refreshes PATH in that same shell, and continues into the CLI's login command, stopping at the first step that fails. The chain operator differs per OS on purpose — Windows PowerShell 5.1 is a possible fallback shell and `&&` is a parser error there, so the Windows spelling nests `if ($?)` instead | `jarvis/clis/external_terminal.py` (`_spawn_windows`, `_spawn_macos`, `_spawn_linux`, `chain_commands`, `path_refresh_command`), `jarvis/ui/web/cli_routes.py::spawn_external`, `tests/unit/clis/test_install_path.py` | Windows: verified live (wt path, composed install+login command). macOS/Linux: same code path, the branch itself unverified from this machine. A box with no screen has no window to open, so there the endpoint falls back to the in-app streaming install job and the UI says so instead of claiming a terminal appeared — a headless server can still install a CLI, it just cannot run an interactive login |
| P-42 | High | Outbound sockets (every lane) | Every connection borrows an ephemeral port from a pool the OS owns, and a closed one keeps that port through TIME_WAIT. The ceiling and the linger differ per OS, and so does what gives out first: **Windows** 16 384 ports / 120 s — the tightest by far, and the port pool is what empties, which stops EVERY process on the machine from connecting (the desktop appears frozen, then heals itself when TIME_WAIT expires); **Linux** 28 232 ports / 60 s, but `RLIMIT_NOFILE` is normally the tighter of the two (1024 on a stock `python:3.11-slim`), so the backend dies of EMFILE while the desktop around it is fine; **macOS** 16 384 ports / 15 s, so it recovers fastest. BUG-215 was the Windows shape: an unjittered wake storm (one socket per pane, per window, per instance, all on one `visibilitychange`) on top of a standing per-call-client burn. The rule that follows is to cap the burst, never to widen a limit — code that fits the Windows budget fits everywhere | `jarvis/ui/web/frontend/src/lib/connectBudget.ts` (`jitteredDelay`, `spreadDelay`, `requestConnect`), `jarvis/core/http_pool.py` (`HttpClientPool`, `SyncHttpClientPool`, `default_limits`), `jarvis/core/socket_budget.py` (`read_platform_limits`, `take_census`, `SocketBudgetWatchdog`), `jarvis/realtime/local_server/supervisor.py::_port_open` (`SO_LINGER`) | Identical on all three: one shared connect budget in the frontend, pooled keep-alive clients in Python, and a watchdog armed by BOTH entry points (desktop shell and `--headless`) that reads the ceiling per platform — `netsh` on Windows (parsed as integers, because it translates its own field names), `/proc/sys/net/ipv4/ip_local_port_range` plus `RLIMIT_NOFILE` on Linux, `sysctl net.inet.ip.portrange.*` on macOS. A host that answers none of them falls back to the documented default and says the number was assumed; a host with no ceiling at all logs one line and throttles nothing, because a watchdog that cannot see must never be what stops the app working. macOS additionally refuses the system-wide socket table to an unprivileged process, so the census there counts this process only and labels the number a floor. Guards: `tests/contract/test_socket_budget.py` (all three hosts faked, plus a German and a Japanese `netsh`), `tests/unit/core/test_socket_budget_watchdog.py`, `jarvis/ui/web/frontend/src/lib/connectBudget.test.ts` |
+| P-45 | Medium | Hermes / OpenClaw agent runtimes | A society agent can run on Hermes or OpenClaw instead of Jarvis' own loop (docs/agent-runtimes.md). Both are separately installed programs driven over ACP: Hermes as one `hermes acp` process per turn on the agent's own `HERMES_HOME`, OpenClaw through `openclaw acp` against a supervised per-agent Gateway. Process containment differs per OS exactly as for every CLI seat: a Job Object on Windows, a process group on POSIX; killing the app reaps the OpenClaw Gateway on Windows (verified live), on POSIX the Gateway is also stopped by the society shutdown and the idle reaper. Install and update use each project's own installer per OS (`install.ps1` on Windows, `install.sh` on macOS/Linux, Hermes' `hermes update`, OpenClaw's `openclaw update --no-restart`) and run only on a button press. OpenClaw needs Node.js 24.16+ or 26.1+; its installer provisions a private Node.js where the system one is older | `jarvis/agent_runtimes/` (`hermes.py`, `openclaw.py`, `base.py::child_env`, `manager.py`), `jarvis/agent_chat/runner_acp.py`, `jarvis/core/process_tree.py` | Windows: both runtimes verified live 2026-10-06 (Hermes 0.20.6, OpenClaw 2026.9.8, local Ollama model, memory read and write through the Jarvis tools). macOS/Linux: the same code path, verified only by the weekly `agent-runtimes-canary.yml` workflow (latest Hermes and OpenClaw, fake model). Headless `python:3.11-slim`: nothing is installed or started unless an agent is switched to a runtime; Hermes' Linux installer needs git and curl, OpenClaw needs a supported Node.js. Guards: `tests/unit/agent_runtimes/`, `tests/unit/society/test_agent_runtime_field.py` |
## Agent conversation continuity and learning (2026-09-07)