<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: José Antonio Garrido</title>
    <description>The latest articles on DEV Community by José Antonio Garrido (@yeyo11).</description>
    <link>https://dev.to/yeyo11</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4204805%2F50ed973a-eaee-4737-9244-f598445c75f1.jpeg</url>
      <title>DEV Community: José Antonio Garrido</title>
      <link>https://dev.to/yeyo11</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/yeyo11"/>
    <language>en</language>
    <item>
      <title>10 agents, 30 GB of RAM and one queue: how they share without clashing</title>
      <dc:creator>José Antonio Garrido</dc:creator>
      <pubDate>Fri, 13 Nov 2026 22:37:55 +0000</pubDate>
      <link>https://dev.to/yeyo11/10-agents-30-gb-of-ram-and-one-queue-how-they-share-without-clashing-2lfm</link>
      <guid>https://dev.to/yeyo11/10-agents-30-gb-of-ram-and-one-queue-how-they-share-without-clashing-2lfm</guid>
      <description>&lt;p&gt;For the two weeks after I published Sluice 0.8.0, I ran it every day on my two machines, both with 30 GiB of RAM, with up to 10 AI agents working at once on one of them. &lt;a href="https://github.com/josegarridodigio/sluice" rel="noopener noreferrer"&gt;Sluice&lt;/a&gt; puts the tests, builds and heavy commands of all the AI agents on a Linux machine into one queue, with a shared CPU and memory budget, and runs each check once per git tree; I told how it started in the &lt;a href="https://josegarrido.dev/en/sluice-shared-queue-so-your-agents-stop-repeating-tests/" rel="noopener noreferrer"&gt;first article&lt;/a&gt;. Even with that queue, my agents' test suites could still run a machine out of memory. How they share it now, in short: the queue decides who runs, the kernel's ceilings keep each job within its share, and the desktop guard keeps the desktop's share free. This is what I learned, and each lesson became a version, from 0.9.0 to 0.12.2:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;A retry is still the same suite&lt;/strong&gt; (0.9.0). Memory admission carries a gate's estimate to its variants and waits after every memory kill.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;When the machine thrashes, only the kernel arrives in time&lt;/strong&gt; (0.10.0). Every &lt;em&gt;gate&lt;/em&gt; job (tests, linters, type checks) runs under a memory ceiling the kernel enforces, even while everything else is stalled.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A browser doesn't stay where you start it&lt;/strong&gt; (0.11.0). Chromium, and so every Playwright browser, moves itself out of its job; Sluice brings it back, so its memory counts, is limited and dies with the job.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The desktop needs a say&lt;/strong&gt; (0.11.0). Each job gets a swap ceiling too, and no job starts while your desktop session is stalling on memory.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The environment is part of what you test&lt;/strong&gt; (0.11.0). Variables such as &lt;code&gt;NODE_OPTIONS&lt;/code&gt; go into the cache key.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A daemon shouldn't inherit whoever starts it&lt;/strong&gt; (0.12.0). One agent session's environment, token included, no longer reaches everyone's jobs.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  A retry is still the same suite
&lt;/h2&gt;

&lt;p&gt;A week after publishing 0.8.0 I went through what had happened on my second machine: 12 threads, 30 GiB of RAM, 8 GiB of swap, and between 4 and 10 agents working at once. In 37 hours there were 11 global out-of-memory kills, 7 kills by &lt;code&gt;systemd-oomd&lt;/code&gt;, 16 test jobs killed for memory and one agent session killed along with them. Swap was full every time.&lt;/p&gt;

&lt;p&gt;There were four causes:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;After a kill, the agents retried with &lt;code&gt;--filter&lt;/code&gt; or &lt;code&gt;--test-concurrency=1&lt;/code&gt;. That was a new command for Sluice, with no history, so it guessed 1.3–1.7 GiB for a suite that needs 11–14 GiB.&lt;/li&gt;
&lt;li&gt;The safety margin after a kill compounded up to 1.5×.&lt;/li&gt;
&lt;li&gt;Memory outside the queue (agents, builds, browsers) grew while a suite ran.&lt;/li&gt;
&lt;li&gt;The agents' &lt;code&gt;systemd-oomd&lt;/code&gt; window was 5 s, and it ended an agent 6 s after a test job was killed.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Version 0.9.0 changed the memory admission:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A variant of a command with other arguments inherits the estimate of its gate instead of a guess.&lt;/li&gt;
&lt;li&gt;Only a guess can start as a probe.&lt;/li&gt;
&lt;li&gt;The margin after a kill is 1.25×.&lt;/li&gt;
&lt;li&gt;After any memory kill, nothing starts for 10 s, and not until the pressure goes down.&lt;/li&gt;
&lt;li&gt;The memory reserve grows to what the rest of the machine grew while heavy jobs ran (the 90th percentile, at most a quarter of the RAM).&lt;/li&gt;
&lt;li&gt;The agents' &lt;code&gt;systemd-oomd&lt;/code&gt; window is 15 s and the jobs' is 8 s, so the job always goes first.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;code&gt;sluice status&lt;/code&gt; now says where the reserve comes from, and flags a job that started alone beyond its estimate. No config change needed.&lt;/p&gt;

&lt;h2&gt;
  
  
  When the machine thrashes, only the kernel arrives in time
&lt;/h2&gt;

&lt;p&gt;With 0.9.0 the same machine hit the next wall. Between 30 October and 1 November one test suite ran 61 times, every time alone on the machine and beyond its estimate: 46 passed, 9 failed their tests and 6 were killed for memory. Each of those six kills was a global OOM, and before each one the system journal fell silent for 22, 30, 37, 67, 72 and about 150 seconds. The whole machine was thrashing, and &lt;code&gt;systemd-oomd&lt;/code&gt; and Sluice's own guard were stalled with everything else: anything that runs in userspace arrives too late.&lt;/p&gt;

&lt;p&gt;Version 0.10.0 hands that job to the kernel. Every second the daemon writes the &lt;code&gt;memory.max&lt;/code&gt; of each job's cgroup, so that all jobs together can never take the machine below a floor. The kernel enforces it even while the daemon is frozen. It is on by default with full containment:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight toml"&gt;&lt;code&gt;&lt;span class="c1"&gt;# ~/.config/sluice/config.toml
&lt;/span&gt;&lt;span class="k"&gt;[admission]&lt;/span&gt;
&lt;span class="na"&gt;memory_reserve&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"auto"&lt;/span&gt;   &lt;span class="c1"&gt;# a tenth of the RAM: 3 GiB on 30 GiB&lt;/span&gt;
&lt;span class="na"&gt;memory_ceiling&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
&lt;span class="na"&gt;memory_floor&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"auto"&lt;/span&gt;     &lt;span class="c1"&gt;# half the reserve: 1.5 GiB on 30 GiB&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;sluice status&lt;/code&gt; shows each running job's ceiling. From 2 November, the next 387 jobs on that machine ran with no OOM and no memory kill, and swap never went above 36 %.&lt;/p&gt;

&lt;p&gt;The trade-off is deliberate: a run that used to pass by pushing the rest of the machine into swap is now killed inside its own job. The machine stays usable, and the message tells the agent to retry once memory is free, or to tell you that the gate doesn't fit.&lt;/p&gt;

&lt;h2&gt;
  
  
  A browser doesn't stay where you start it
&lt;/h2&gt;

&lt;p&gt;On 5 November it was my development machine's turn: 20 threads, 30 GiB of RAM, 8 GiB of swap, GNOME on Wayland, Sluice 0.10.0. Between 18:40 and 19:20 a frontend test suite of about 14.5–15 GiB started at three times its estimate, Playwright jobs took 7.7–9.4 GiB each, and a production build ran outside Sluice at the same time. The machine reached 21 GiB used (66 %), swap went from 3.6 to 5.2 GiB, swap-out peaked at 1,759 pages per second, load hit 32, and GNOME Shell's input lag reached 61–80 ms. There was no OOM and nothing was killed: the 0.10.0 ceiling never engaged. The shell ended up not responding, and at 20:37 I rebooted with SysRq.&lt;/p&gt;

&lt;p&gt;I still don't know what hung the shell: it stayed hung after the memory recovered. But looking into it I found something else. That day systemd had created 385 Chromium scopes on the machine, and that is where the browsers started by the test jobs had gone: outside their jobs.&lt;/p&gt;

&lt;p&gt;This is what happens. At startup, every Chromium browser process, headless included, prepares the connection to the XDG desktop portal. The portal needs an app id, and Chromium gets one by asking the systemd user manager, over the session bus, for a new scope with its own pid: &lt;code&gt;StartTransientUnit&lt;/code&gt;. The process ends up in &lt;code&gt;app.slice/app-org.chromium.Chromium-&amp;lt;pid&amp;gt;.scope&lt;/code&gt;. There is no flag to turn it off.&lt;/p&gt;

&lt;p&gt;For a job runner that means the browser's memory leaves the job's accounting, its learned peak, its &lt;code&gt;memory.max&lt;/code&gt; and its kill. And Playwright starts browsers in a process group of their own, so a process-group kill misses them too.&lt;/p&gt;

&lt;p&gt;I checked it on 6 November with a probe: a headless shell running for 6–8 seconds, about 200 MB. The browser process moved to its own scope; the renderers it had already forked stayed in the job.&lt;/p&gt;

&lt;p&gt;The cheap fixes didn't hold up:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Unsetting &lt;code&gt;DBUS_SESSION_BUS_ADDRESS&lt;/code&gt; only works for Chromium, and breaks the tests that need the session bus.&lt;/li&gt;
&lt;li&gt;The &lt;code&gt;FLATPAK_SANDBOX_DIR&lt;/code&gt; trick, which skips the move, stopped working in Chromium on 14 October.&lt;/li&gt;
&lt;li&gt;A cgroup namespace doesn't help: systemd makes the move from the root namespace.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;What works is a property of cgroup v2. To move a process, the kernel only asks for write access to the &lt;code&gt;cgroup.procs&lt;/code&gt; of the common ancestor of both cgroups, and that ancestor is &lt;code&gt;user@UID.service&lt;/code&gt;, which belongs to you. So since 0.11.0, every second the daemon walks each job's process tree and writes any descendant it finds outside back into the job's cgroup. This is a job on 0.12.1 that starts Playwright's headless Chromium (156) directly. The browser leaves its cgroup 265 ms after the job starts, and it's back in the same tick:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fi4za2ao694vdfz4r50kt.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fi4za2ao694vdfz4r50kt.png" alt="Sluice's daemon log on 0.12.1: chrome-headless leaves the job's cgroup for its own Chromium scope and is moved back in the same tick" width="800" height="320"&gt;&lt;/a&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;INFO sluice_gate_daemon::server: moved a process of the job back into its cgroup job=1794597479890-504544-15a79e pid=643155 comm=chrome-headless from=/user.slice/user-$UID.slice/user@$UID.service/app.slice/app-org.chromium.Chromium-643155.scope
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;When the job ends, whatever is left of it is killed, inside its cgroup or outside it: escapees through a pidfd, after checking the process start time, so a reused pid is never signalled. An integration test reproduces the escape with the same &lt;code&gt;StartTransientUnit&lt;/code&gt; call.&lt;/p&gt;

&lt;p&gt;It is on by default (&lt;code&gt;[containment] reclaim_escaped = true&lt;/code&gt;), and it applies to every job: the setting lives in your user config, not in each gate. If your tests deliberately start something with &lt;code&gt;systemd-run --user --scope&lt;/code&gt;, or daemonise a process that must outlive the job, the daemon will pull those back too; for that case, set it to &lt;code&gt;false&lt;/code&gt; and Sluice only reports escapes. What Sluice itself places, in its agents scope or in any slice below its own (as when a test runs Sluice inside a job), is not an escape. Anything else, Chromium's scopes included, is moved back.&lt;/p&gt;

&lt;h2&gt;
  
  
  The desktop needs a say
&lt;/h2&gt;

&lt;p&gt;The same version, 0.11.0, adds two more limits:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight toml"&gt;&lt;code&gt;&lt;span class="k"&gt;[admission]&lt;/span&gt;
&lt;span class="na"&gt;swap_ceiling&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
&lt;span class="na"&gt;swap_floor&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"auto"&lt;/span&gt;     &lt;span class="c1"&gt;# a quarter of the swap&lt;/span&gt;
&lt;span class="na"&gt;desktop_guard&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Swap ceiling.&lt;/strong&gt; Every second the daemon also writes each job's &lt;code&gt;memory.swap.max&lt;/code&gt;, so that the jobs together can't take the free swap below the floor. A job at its memory ceiling dies in its own cgroup instead of swapping the machine out.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Desktop guard.&lt;/strong&gt; Sluice reads the memory pressure of your desktop session (&lt;code&gt;session.slice&lt;/code&gt; of the systemd user manager). While it is at or above 10 % (&lt;code&gt;some avg10&lt;/code&gt;, until it drops under 5 %), no job starts, not even alone on the machine, and the ceilings keep the whole reserve free.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Your jobs will wait while the desktop is under pressure; that's the point. &lt;code&gt;sluice status&lt;/code&gt; shows each running job's ceiling and the session's pressure on its &lt;code&gt;memory:&lt;/code&gt; line. Here with a single light job on an idle machine, so swap, pressure and escapes, which it only prints when they are not zero, don't show up:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fdb1vrsartml8kn8hk6bg.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fdb1vrsartml8kn8hk6bg.png" alt="sluice status on 0.12.1 with one light job running: its 22.1 GiB ceiling and the memory: line with the desktop's pressure at 0.0 %" width="800" height="355"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  The environment is part of what you test
&lt;/h2&gt;

&lt;p&gt;Also in 0.11.0: a variable such as &lt;code&gt;NODE_OPTIONS&lt;/code&gt; or &lt;code&gt;RUSTFLAGS&lt;/code&gt; changes what a test checks without changing the tree. With &lt;code&gt;key_env&lt;/code&gt; its value goes into the cache key, and requests with other values never share a pass. &lt;code&gt;sluice init&lt;/code&gt; writes them per toolchain, together with the file the package manager rewrites on every install. On a throwaway npm project:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight toml"&gt;&lt;code&gt;&lt;span class="k"&gt;[gates.test]&lt;/span&gt;
&lt;span class="na"&gt;cmd&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"npm test"&lt;/span&gt;
&lt;span class="na"&gt;weight&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"auto"&lt;/span&gt;
&lt;span class="na"&gt;timeout&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"30m"&lt;/span&gt;
&lt;span class="na"&gt;hooks&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"pre-push"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="na"&gt;key_inputs&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"node --version"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"npm --version"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="na"&gt;key_env&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"NODE_OPTIONS"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"NODE_ENV"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="na"&gt;key_files&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"node_modules/.package-lock.json"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="na"&gt;env&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="no"&gt;CI&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"1"&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;sluice doctor&lt;/code&gt; warns when a gate leaves them out:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;[warn] key-env        gate 'test': key_env leaves out RUSTFLAGS, RUSTDOCFLAGS, CARGO_BUILD_TARGET (a change to them reuses a pass made with other values); needs sluice &amp;gt;= 0.11.0 to read key_env
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Adding &lt;code&gt;key_env&lt;/code&gt; changes each gate's key once, so each gate runs once more.&lt;/p&gt;

&lt;h2&gt;
  
  
  A daemon shouldn't inherit whoever starts it
&lt;/h2&gt;

&lt;p&gt;Every job descends from the daemon, and an agent session can start the daemon on its own. Since 0.12.0 the daemon doesn't keep the environment of whoever started it, so one agent session's id, API address and bearer token never reach anyone else's jobs. A check that asks "am I under an agent?" by walking up the process tree no longer mistakes your own runs for an agent's, and merge trains, which run their gates, their &lt;code&gt;prepare&lt;/code&gt; and their &lt;code&gt;key_inputs&lt;/code&gt; in the daemon's environment, never see the token.&lt;/p&gt;

&lt;p&gt;The daemon keeps only an allowlist (&lt;code&gt;PATH&lt;/code&gt;, &lt;code&gt;HOME&lt;/code&gt;, the locale, &lt;code&gt;XDG_*&lt;/code&gt;, the session bus, &lt;code&gt;SLUICE_*&lt;/code&gt; and a few more), and a &lt;code&gt;sluice daemon&lt;/code&gt; started by hand re-executes itself clean. The log names the dropped variables that look like credentials, without showing their values. Gates started by &lt;code&gt;run&lt;/code&gt;, &lt;code&gt;verify&lt;/code&gt; or a hook still get the environment of whoever asked for them. The API keys your shell profile exports no longer reach the daemon: merge trains get them from your login shell (the default &lt;code&gt;tool_env&lt;/code&gt;), and with &lt;code&gt;[queue] tool_env = "daemon"&lt;/code&gt; you have to name the ones they need, such as a proxy, in &lt;code&gt;pass_env&lt;/code&gt;.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight toml"&gt;&lt;code&gt;&lt;span class="c1"&gt;# ~/.config/sluice/config.toml
&lt;/span&gt;&lt;span class="k"&gt;[daemon]&lt;/span&gt;
&lt;span class="na"&gt;pass_env&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"HTTPS_PROXY"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;And a gate can drop variables from its own environment with &lt;code&gt;env_remove&lt;/code&gt;, for markers that &lt;code&gt;env&lt;/code&gt; can't unset.&lt;/p&gt;

&lt;h2&gt;
  
  
  Update to 0.12.2
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;sluice update
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;It verifies the checksum, and it only stops the daemon if it is idle: one running gates keeps going until its next restart. If you use the Claude Code plugin, update it too, and then restart your agent sessions, which keep the old &lt;code&gt;sluice mcp&lt;/code&gt; until they reconnect:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;claude plugin marketplace update sluice
claude plugin update sluice@sluice
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Then check it:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;sluice doctor   &lt;span class="c"&gt;# daemon-version and plugin both say 0.12.2, plus any key_env warnings&lt;/span&gt;
sluice status   &lt;span class="c"&gt;# the daemon version, and the memory: line with the desktop's pressure&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;0.12.1 fixes the escape detection of 0.11.0 and 0.12.0. If you're on either and can't update yet, turn off the escape handling in your user config:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight toml"&gt;&lt;code&gt;&lt;span class="c1"&gt;# ~/.config/sluice/config.toml
&lt;/span&gt;&lt;span class="k"&gt;[containment]&lt;/span&gt;
&lt;span class="na"&gt;reclaim_escaped&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;false&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;and restart the daemon while it is idle with &lt;code&gt;sluice daemon stop&lt;/code&gt; (it drops queued jobs). With &lt;code&gt;false&lt;/code&gt; Sluice neither moves processes back nor kills leftovers at the end of a job; the detection still runs, so you may see a burst of &lt;code&gt;WARN&lt;/code&gt; lines. Once updated, remove the line to get the containment back, unless your own tests need it.&lt;/p&gt;

&lt;p&gt;None of these versions breaks an existing config. The new keys are one-way: a shared &lt;code&gt;.sluice.toml&lt;/code&gt; that uses &lt;code&gt;key_env&lt;/code&gt; needs every machine on 0.11.0 or later, and one that uses &lt;code&gt;env_remove&lt;/code&gt;, on 0.12.0.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try it
&lt;/h2&gt;

&lt;p&gt;You need Linux. Containment needs cgroup v2 and a systemd user manager, and the memory policy needs &lt;code&gt;systemd-oomd&lt;/code&gt; with systemd 257 or later; in a container or on cgroup v1 Sluice runs without containment, and &lt;code&gt;sluice doctor&lt;/code&gt; tells you why. The memory work in this article comes from Ubuntu 26.04 machines with kernel 7.0.&lt;/p&gt;

&lt;p&gt;If you're new to it: on a 4-CPU GitHub runner, with 0.9.0 (median of 3 rounds), Sluice cut the time until every agent had committed from 103 to 72 s with 4 agents (−30 %) and from 213 to 119 s with 8 (−44 %).&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;curl -fsSL https://raw.githubusercontent.com/josegarridodigio/sluice/main/scripts/install.sh &lt;span class="o"&gt;|&lt;/span&gt; sh
sluice doctor
sluice init --dry-run
sluice init
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The code, the CHANGELOG and the decision behind each change (ADR-0026 to ADR-0030) are at &lt;a href="https://github.com/josegarridodigio/sluice" rel="noopener noreferrer"&gt;github.com/josegarridodigio/sluice&lt;/a&gt;. If it's useful to you, a star there helps other people find it. And if you want the next version when it ships, with what I learned running it, the newsletter is just below.&lt;/p&gt;

</description>
      <category>linux</category>
      <category>ai</category>
      <category>devops</category>
      <category>opensource</category>
    </item>
    <item>
      <title>Shipcast v0.3.0: launch from a GitHub Action, blog in your languages, an app you can install</title>
      <dc:creator>José Antonio Garrido</dc:creator>
      <pubDate>Tue, 03 Nov 2026 07:50:13 +0000</pubDate>
      <link>https://dev.to/yeyo11/shipcast-v030-launch-from-a-github-action-blog-in-your-languages-an-app-you-can-install-56ig</link>
      <guid>https://dev.to/yeyo11/shipcast-v030-launch-from-a-github-action-blog-in-your-languages-an-app-you-can-install-56ig</guid>
      <description>&lt;p&gt;Shipcast turns a GitHub release into a launch: it reads the code at the tag, drafts the article and a post for each channel, and publishes them once you approve. Version 0.3.0 lets you run it from a GitHub Action on your own repos with nothing to host, writes your blog in the languages you choose, and brings a redesigned app you can install on your phone or desktop.&lt;/p&gt;

&lt;p&gt;If you already run Shipcast, this post covers what changed and what to do when you upgrade.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fc3xuo1l1otivalmocv47.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fc3xuo1l1otivalmocv47.gif" alt="Shipcast's app: a release's drafts, approved and published" width="760" height="475"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Why a GitHub Action?
&lt;/h2&gt;

&lt;p&gt;Until now you needed a server to use Shipcast. That is fine for me, but it is a lot to ask of someone who only wants their next release announced. With v0.3.0 the whole flow runs in GitHub Actions: you publish a release, one drafts pull request arrives in your launches repo with the article and a post per channel, and when you merge it each channel is published once.&lt;/p&gt;

&lt;h2&gt;
  
  
  How do I set up the Action?
&lt;/h2&gt;

&lt;p&gt;In your project's repo, with Node 24:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npx @yeyo11/shipcast init
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;init&lt;/code&gt; writes the launch workflow that uses &lt;code&gt;yeyo11/shipcast-action@v1&lt;/code&gt;, &lt;code&gt;.github/launch.yml&lt;/code&gt;, and, for your launches repo, &lt;code&gt;brand.yml&lt;/code&gt; plus a publish workflow. It then prints every secret you need to set. You can pass the choices up front:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npx @yeyo11/shipcast init &lt;span class="nt"&gt;--launches-repo&lt;/span&gt; you/launches &lt;span class="nt"&gt;--ai&lt;/span&gt; openai &lt;span class="nt"&gt;--tone&lt;/span&gt; &lt;span class="s2"&gt;"Plain, practical, first person."&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The drafts are written with your own key. &lt;code&gt;--ai&lt;/code&gt; takes &lt;code&gt;anthropic&lt;/code&gt; (the default) or &lt;code&gt;openai&lt;/code&gt;, and the action's &lt;code&gt;ai-base-url&lt;/code&gt; input points it at any OpenAI-compatible server. To check a setup without posting anything, set the repository variable &lt;code&gt;SHIPCAST_DRY_RUN=true&lt;/code&gt;: the publish run lists what it would post.&lt;/p&gt;

&lt;p&gt;Every link to your blog goes out with &lt;code&gt;utm_source&lt;/code&gt;, &lt;code&gt;utm_medium&lt;/code&gt; and &lt;code&gt;utm_campaign&lt;/code&gt;, so your analytics show which channel each visit came from. dev.to and Hashnode keep the clean canonical URL.&lt;/p&gt;

&lt;h2&gt;
  
  
  What if GitHub's cron runs late?
&lt;/h2&gt;

&lt;p&gt;Scheduled posts and retries run in a "round". GitHub delays or drops &lt;code&gt;schedule&lt;/code&gt; runs, so the publish workflow has three cron lines only as a backstop and accepts &lt;code&gt;workflow_dispatch&lt;/code&gt;. For rounds on time, dispatch it every 15 minutes from outside GitHub: a Cloudflare Worker, cron-job.org or your own server. &lt;code&gt;init&lt;/code&gt; prints the exact call:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;curl &lt;span class="nt"&gt;-fsS&lt;/span&gt; &lt;span class="nt"&gt;-X&lt;/span&gt; POST &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;-H&lt;/span&gt; &lt;span class="s2"&gt;"Authorization: Bearer &lt;/span&gt;&lt;span class="nv"&gt;$SHIPCAST_DISPATCH_TOKEN&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;-H&lt;/span&gt; &lt;span class="s2"&gt;"Accept: application/vnd.github+json"&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  https://api.github.com/repos/&amp;lt;you&amp;gt;/launches/actions/workflows/shipcast-publish.yml/dispatches &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;-d&lt;/span&gt; &lt;span class="s1"&gt;'{"ref":"main"}'&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The token is a fine-grained one for the launches repo only, with Actions read and write. A late round only delays a post; it loses none.&lt;/p&gt;

&lt;h2&gt;
  
  
  How do I choose my blog's languages?
&lt;/h2&gt;

&lt;p&gt;List them in &lt;code&gt;brand.yml&lt;/code&gt; with any ISO 639-1 code. The first one is the primary language:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="c1"&gt;# brand.yml&lt;/span&gt;
&lt;span class="na"&gt;languages&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;blog&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;[&lt;/span&gt;&lt;span class="nv"&gt;en&lt;/span&gt;&lt;span class="pi"&gt;,&lt;/span&gt; &lt;span class="nv"&gt;es&lt;/span&gt;&lt;span class="pi"&gt;]&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The article, the newsletter issue and the posts follow that list, and so do the language switches in the app. dev.to and Hashnode republish the English version when there is one, otherwise the first language. Watch out when upgrading: without &lt;code&gt;languages.blog&lt;/code&gt;, Shipcast now writes in English only.&lt;/p&gt;

&lt;h2&gt;
  
  
  What changed in the app?
&lt;/h2&gt;

&lt;p&gt;Every screen was rebuilt. Launches wait for you and you approve them in the app. Each draft opens in an editor with Markdown and Visual modes, and its toolbar matches what the channel can format. Stats show each channel and each launch, a search palette jumps to any launch, account or page, and &lt;strong&gt;Sync all&lt;/strong&gt; refreshes every account on Channels.&lt;/p&gt;

&lt;p&gt;The app also installs. On a phone or a desktop it opens standalone, shows its own offline page when the connection drops, and offers &lt;strong&gt;Reload&lt;/strong&gt; when a new version is out, so nothing reloads in the middle of an edit.&lt;/p&gt;

&lt;h2&gt;
  
  
  How do notifications work?
&lt;/h2&gt;

&lt;p&gt;Shipcast tells your phone or desktop when a reply to a comment or a launch waits for your approval, when something fails, and when a launch is out. Turn it on per device in Settings → Notifications, with a switch for each event. On iPhone, add Shipcast to the Home Screen first. A notification never shows a comment or a draft's text. On your own server, set &lt;code&gt;SHIPCAST_VAPID_PUBLIC_KEY&lt;/code&gt; and &lt;code&gt;SHIPCAST_VAPID_PRIVATE_KEY&lt;/code&gt; (see &lt;code&gt;docs/push.md&lt;/code&gt;).&lt;/p&gt;

&lt;h2&gt;
  
  
  How do I upgrade a self-hosted install?
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git pull
pnpm &lt;span class="nb"&gt;install
&lt;/span&gt;pnpm app          &lt;span class="c"&gt;# database migrations run on start&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Two things to check:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;claudio now starts behind its own Compose profile: &lt;code&gt;docker compose --profile claudio up -d&lt;/code&gt;, or &lt;code&gt;COMPOSE_PROFILES=claudio&lt;/code&gt; in &lt;code&gt;.env&lt;/code&gt;. Without either, &lt;code&gt;docker compose up -d&lt;/code&gt; starts only Postgres.&lt;/li&gt;
&lt;li&gt;If your blog has more than English, list its languages in &lt;code&gt;languages.blog&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Where do I go next?
&lt;/h2&gt;

&lt;p&gt;The step-by-step guide for the Action is in &lt;a href="https://github.com/yeyo11/shipcast/blob/main/docs/getting-started.md" rel="noopener noreferrer"&gt;docs/getting-started.md&lt;/a&gt;, and the full list of changes is in the &lt;a href="https://github.com/yeyo11/shipcast/blob/main/CHANGELOG.md" rel="noopener noreferrer"&gt;changelog&lt;/a&gt;. If you don't have a blog yet, &lt;a href="https://github.com/yeyo11/shipcast-blog" rel="noopener noreferrer"&gt;&lt;code&gt;yeyo11/shipcast-blog&lt;/code&gt;&lt;/a&gt; is an Astro and Tailwind template that already reads Shipcast's articles and deploys on GitHub Pages.&lt;/p&gt;

&lt;p&gt;If Shipcast saves you writing the same announcement ten times, a star on &lt;a href="https://github.com/yeyo11/shipcast" rel="noopener noreferrer"&gt;the repository&lt;/a&gt; helps other developers find it.&lt;/p&gt;

</description>
      <category>opensource</category>
      <category>githubactions</category>
      <category>ai</category>
      <category>showdev</category>
    </item>
    <item>
      <title>Sluice: one queue for every build, test and heavy command your agents run</title>
      <dc:creator>José Antonio Garrido</dc:creator>
      <pubDate>Thu, 29 Oct 2026 14:20:12 +0000</pubDate>
      <link>https://dev.to/yeyo11/sluice-one-queue-for-every-build-test-and-heavy-command-your-agents-run-1jjj</link>
      <guid>https://dev.to/yeyo11/sluice-one-queue-for-every-build-test-and-heavy-command-your-agents-run-1jjj</guid>
      <description>&lt;p&gt;&lt;a href="https://github.com/josegarridodigio/sluice" rel="noopener noreferrer"&gt;Sluice&lt;/a&gt; is a verification queue and cache shared by all the AI agents on a Linux machine: it runs each &lt;em&gt;gate&lt;/em&gt; (tests, linters, type checks) only once per git tree, under a common CPU and memory budget, and stores the result. It is open source (MIT license), written in Rust, and works with any AI coding agent: the git hooks need nothing from the agent, agents that support MCP connect to its MCP server, and Claude Code also has a plugin. I built it, and in this article I tell you why, how to install it and what has changed on my machines, with the measured numbers.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fznx4vcd95m5ruubi6ldl.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fznx4vcd95m5ruubi6ldl.png" alt="sluice status on a machine with agents working all day: 1,874 runs, 1,147 cache answers and 19 h 24 min saved" width="800" height="304"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What problem does it solve?
&lt;/h2&gt;

&lt;p&gt;In my day job I build software for clients with AI agents. On a normal day I have dozens of agents running at once (I use Claude Code), each in its own git &lt;em&gt;worktree&lt;/em&gt;, on projects with expensive checks: test suites that take several minutes, linters and type checks wired into &lt;code&gt;pre-commit&lt;/code&gt; and &lt;code&gt;pre-push&lt;/code&gt;. Those hooks are defined by each project's team and I can't always touch them.&lt;/p&gt;

&lt;p&gt;Nothing coordinated those agents. Working with several AI agents in parallel, my machine spent the day running the same tests and builds over and over, until it ran out of memory, and pushes took forever. What made me say "enough" was watching the desktop give up: GNOME stopped responding and Linux started killing processes on its own. The kernel's OOM killer took out the browser and the applications, and &lt;code&gt;systemd-oomd&lt;/code&gt; took out the agents' own tools.&lt;/p&gt;

&lt;p&gt;There were three separate causes behind it:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Uncontrolled concurrency.&lt;/strong&gt; Each agent launches its checks on its own, directly or from git hooks.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Redundancy.&lt;/strong&gt; The same tree is verified many times: the agent before committing, then &lt;code&gt;pre-commit&lt;/code&gt;, then &lt;code&gt;pre-push&lt;/code&gt; (which repeats &lt;code&gt;pre-commit&lt;/code&gt;), and again after a &lt;em&gt;rebase&lt;/em&gt; that changes nothing. I measured it with Sluice itself: of all the checks requested, 52% on the development machine (1,426 of 2,742) and 38% on the second machine (1,142 of 3,016) were on code that was already verified.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Excessive scope.&lt;/strong&gt; Full suites where a subset would do. That is up to each project, not Sluice.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;And one constraint that complicates everything: an agent's shell tool has a timeout. A hook that sits waiting in a queue inside &lt;code&gt;git commit&lt;/code&gt; ends up cut off, and the agent still doesn't know whether the commit happened. That's why Sluice answers fast in hooks and really waits over MCP.&lt;/p&gt;

&lt;h2&gt;
  
  
  What do you need?
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Linux (it only works on Linux) with &lt;code&gt;git&lt;/code&gt; 2.31 or later. There are static binaries for x86_64 and aarch64.&lt;/li&gt;
&lt;li&gt;An AI coding agent. Any agent that supports MCP can use the MCP server (&lt;code&gt;sluice mcp&lt;/code&gt;); for Claude Code there is also a plugin that sets everything up.&lt;/li&gt;
&lt;li&gt;To isolate jobs: cgroup v2 and a systemd user manager. The memory policy uses &lt;code&gt;systemd-oomd&lt;/code&gt; with systemd 257 or later. &lt;code&gt;sluice doctor&lt;/code&gt; tells you what you have.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  How do I install it?
&lt;/h2&gt;

&lt;p&gt;The binary installs to &lt;code&gt;~/.local/bin&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;curl &lt;span class="nt"&gt;-fsSL&lt;/span&gt; https://raw.githubusercontent.com/josegarridodigio/sluice/main/scripts/install.sh | sh
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;SLUICE_VERSION&lt;/code&gt; pins a specific version and, later on, &lt;code&gt;sluice update&lt;/code&gt; updates in place while verifying the checksum. Then connect your agent. In Claude Code, install the plugin:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;/plugin marketplace add josegarridodigio/sluice
/plugin install sluice@sluice
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;With any other agent that supports MCP, register &lt;code&gt;sluice mcp&lt;/code&gt; as an MCP server in its configuration and paste into its &lt;code&gt;AGENTS.md&lt;/code&gt; the instruction block from the &lt;a href="https://github.com/josegarridodigio/sluice/blob/main/docs/agents.md" rel="noopener noreferrer"&gt;agents guide&lt;/a&gt;. If the agent sets no variable Sluice recognises, export &lt;code&gt;SLUICE_AGENT=1&lt;/code&gt; in its shell so the hooks know it is an agent; and if it only has a shell, &lt;code&gt;sluice shim install&lt;/code&gt;, with the shims directory first in its &lt;code&gt;PATH&lt;/code&gt;, puts its builds and tests in the queue too.&lt;/p&gt;

&lt;p&gt;And in each repository, first look at what it would do and then write it:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;sluice init &lt;span class="nt"&gt;--dry-run&lt;/span&gt;   &lt;span class="c"&gt;# detects the stack and your hooks; shows the plan, writes nothing&lt;/span&gt;
sluice init             &lt;span class="c"&gt;# writes .sluice.toml and rewires your hooks&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;With the Claude Code plugin you don't need to touch the &lt;code&gt;PATH&lt;/code&gt; or &lt;code&gt;CLAUDE.md&lt;/code&gt;: at the start of each session, it installs some shell &lt;em&gt;shims&lt;/em&gt;, puts them first in the session's &lt;code&gt;PATH&lt;/code&gt; and gives the agent the rules. A &lt;em&gt;gate&lt;/em&gt; is a named command in &lt;code&gt;.sluice.toml&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight toml"&gt;&lt;code&gt;&lt;span class="n"&gt;version&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;

&lt;span class="k"&gt;[&lt;/span&gt;&lt;span class="n"&gt;gates&lt;/span&gt;&lt;span class="k"&gt;.&lt;/span&gt;&lt;span class="n"&gt;test&lt;/span&gt;&lt;span class="k"&gt;]&lt;/span&gt;
&lt;span class="n"&gt;cmd&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s"&gt;"npm test -- --maxWorkers=2"&lt;/span&gt;
&lt;span class="n"&gt;weight&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="mi"&gt;4&lt;/span&gt;
&lt;span class="n"&gt;hooks&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;"pre-commit"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;"pre-push"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;weight&lt;/code&gt; is how many units of the budget the &lt;em&gt;gate&lt;/em&gt; takes up, roughly the CPU threads it uses. With &lt;code&gt;weight = "auto"&lt;/code&gt;, Sluice starts at half the budget and learns a lower one from the measured runs.&lt;/p&gt;

&lt;h2&gt;
  
  
  What happens when a tree has already passed?
&lt;/h2&gt;

&lt;p&gt;It doesn't run again. The cache key is the exact content of the working tree plus the &lt;em&gt;gate&lt;/em&gt; definition, and all the repository's &lt;em&gt;worktrees&lt;/em&gt; share it. If another agent, or your &lt;code&gt;pre-commit&lt;/code&gt; hook, already verified that tree, the answer comes from the cache without even going through the daemon:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgtxpmrhlap4e46v4h2ks.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgtxpmrhlap4e46v4h2ks.png" alt="sluice gate list and two sluice run answered from the cache: typecheck in 0.22 s and test in 0.24 s" width="800" height="190"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;That &lt;code&gt;typecheck&lt;/code&gt; took 54 seconds the last time it really ran; now it answers in 0.22 s. In this repository the answer includes running &lt;code&gt;pnpm --version&lt;/code&gt;, because it's declared in &lt;code&gt;key_inputs&lt;/code&gt;: the output of those commands goes into the key, so changing pnpm version invalidates the cache, and they run on every query. Without them, on my development machine, a cache answer costs about 25–30 ms.&lt;/p&gt;

&lt;p&gt;If you want to see why Sluice decides what it decides, &lt;code&gt;--explain&lt;/code&gt; shows you the tree, the key and the lookup result without running anything:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F806k1hmbr80gztmn5jqz.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F806k1hmbr80gztmn5jqz.png" alt="sluice run --explain typecheck: the git tree, the cache key and a HIT from an hour ago" width="799" height="198"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;If two agents ask for the same thing at the same time, it runs once and both get the result (&lt;em&gt;coalescing&lt;/em&gt;).&lt;/p&gt;

&lt;p&gt;This is what has been saved, measured in each daemon's database, not counting cancelled jobs:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;Second machine (12 threads, 30 GB)&lt;/th&gt;
&lt;th&gt;Development machine (20 threads, 30 GB)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Period&lt;/td&gt;
&lt;td&gt;Oct 24 → 29 (5.8 days)&lt;/td&gt;
&lt;td&gt;Oct 22 → 28&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Checks run&lt;/td&gt;
&lt;td&gt;1,874&lt;/td&gt;
&lt;td&gt;1,316&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cache answers&lt;/td&gt;
&lt;td&gt;1,142&lt;/td&gt;
&lt;td&gt;1,426&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Run time saved&lt;/td&gt;
&lt;td&gt;19.2 hours&lt;/td&gt;
&lt;td&gt;8.6 hours&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;In total, about 28 hours of tests and linters that did not run in a week, because that exact code was already verified. On the second machine, the daily saving ranges from 1.9 to 5 hours. The screenshot at the top is from that machine, a few hours later, with a few more cache answers.&lt;/p&gt;

&lt;p&gt;Sluice doesn't make tests faster: it avoids repeating them, orders when they run and protects the machine.&lt;/p&gt;

&lt;h2&gt;
  
  
  How does it keep the machine from running out of memory?
&lt;/h2&gt;

&lt;p&gt;On the second machine, with 5 agents working at once, the system log shows out-of-memory episodes on three different days (October 22, 25 and 26). In the worst one, on the morning of the 26th, the system was killing processes for about 20 minutes, up to 6 per minute. Sluice recorded 15 interventions by the kernel or &lt;code&gt;systemd-oomd&lt;/code&gt; on agent sessions, and a single &lt;em&gt;gate&lt;/em&gt; reached 18 GB.&lt;/p&gt;

&lt;p&gt;Version 0.6.0 (October 26) changed three things:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Memory admission.&lt;/strong&gt; Sluice learns how much memory each &lt;em&gt;gate&lt;/em&gt; uses (the largest &lt;em&gt;working set&lt;/em&gt; of its last 5 runs, plus 20%) and doesn't start one that doesn't fit in the available memory minus a reserve for the desktop and the agents (by default, 10% of memory).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Isolation.&lt;/strong&gt; Each job runs in its own cgroup.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Preferred victims.&lt;/strong&gt; If memory still runs short, the kernel and &lt;code&gt;systemd-oomd&lt;/code&gt; pick a verification job before your desktop or your agents.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;code&gt;sluice doctor&lt;/code&gt; shows you how it ends up configured on your machine:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fx4mqe8x83tlgb5fdjll0.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fx4mqe8x83tlgb5fdjll0.png" alt="sluice doctor: full containment with cgroup v2, jobs with oom_score_adj of 800 or more and systemd-oomd acting on gates before agents" width="800" height="349"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Since the afternoon of October 26: &lt;strong&gt;0 out-of-memory episodes&lt;/strong&gt; on the second machine, across about 780 checks and 2.5 days of agents working, nights included. I don't count a deliberate, bounded test I ran that same day at noon.&lt;/p&gt;

&lt;p&gt;Version 0.8.0 fixed the opposite case: a &lt;em&gt;gate&lt;/em&gt; with no history reserved an inflated estimate. A &lt;code&gt;pytest&lt;/code&gt; reserved 13.8 GB, waited 26 minutes, ran in 1 min 40 s and used around 1 GB. Now the first run starts as a probe, measures what it really uses and also learns from the ones that fail: waits caused by guessed estimates went from 7 in one day to 0 the first night.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why did a 0.1-second linter wait 23 minutes?
&lt;/h2&gt;

&lt;p&gt;Because it was waiting behind a giant. On October 28, with the previous version, the test suite of a pnpm monorepo used about 12 GB on each run (20 measured runs, between 11 and 13 GB). With 30 GB only one fits at a time. When that suite waited for memory at the head of the queue, it reserved its turn and everything else waited behind it:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;a linter that takes 0.1 seconds waited between 15 and 23 minutes;&lt;/li&gt;
&lt;li&gt;a 19-second &lt;code&gt;typecheck&lt;/code&gt; waited about 4 minutes;&lt;/li&gt;
&lt;li&gt;48% of all queue time was of this kind, and 91% of those jobs lasted less than a minute.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Meanwhile the CPU was almost idle: 40% of the time with jobs in the queue, it was idle.&lt;/p&gt;

&lt;p&gt;Version 0.8.0 brings &lt;em&gt;backfilling&lt;/em&gt;, the technique used by supercomputing schedulers such as Slurm. Sluice predicts when the head job can start from how long the running jobs take, and lets one from behind go ahead only if it fits now and doesn't delay the head: either because the head will still fit next to it, or because its learned duration, with margin, ends sooner. &lt;code&gt;[scheduler] backfill = false&lt;/code&gt; goes back to strict reservation.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;Before: Oct 28 day, 12 h&lt;/th&gt;
&lt;th&gt;After: night of Oct 28–29 with 0.8.0, 12 h&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Checks&lt;/td&gt;
&lt;td&gt;316&lt;/td&gt;
&lt;td&gt;202&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Run minutes&lt;/td&gt;
&lt;td&gt;510&lt;/td&gt;
&lt;td&gt;380&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Queue wait minutes&lt;/td&gt;
&lt;td&gt;981&lt;/td&gt;
&lt;td&gt;167&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Wait per minute of work&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;1.92 min&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;0.44 min&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Worst wait of a job under 1 min&lt;/td&gt;
&lt;td&gt;27 min&lt;/td&gt;
&lt;td&gt;12 min&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Idle CPU while there was a queue&lt;/td&gt;
&lt;td&gt;~40%&lt;/td&gt;
&lt;td&gt;4.8%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Jobs that went ahead of the head&lt;/td&gt;
&lt;td&gt;—&lt;/td&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Total delay that caused to heads&lt;/td&gt;
&lt;td&gt;—&lt;/td&gt;
&lt;td&gt;4 min 52 s&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Read it carefully: it is not a controlled experiment. It's 12 hours of daytime with the old version against 12 hours of night with the new one, with different workloads. That's why I compare wait per minute of work, about 4.4 times lower, and not absolute wait. And there is a cost: letting jobs through delayed the heads by 4 min 52 s in total that night. Sluice measures it and shows it in &lt;code&gt;sluice status&lt;/code&gt; (the &lt;code&gt;backfill&lt;/code&gt; line in the screenshot at the top) precisely so you can keep an eye on it.&lt;/p&gt;

&lt;h2&gt;
  
  
  What if a test hangs?
&lt;/h2&gt;

&lt;p&gt;On October 28, a project's tests hung four times, waiting for something that never arrived. Each time they held the queue and up to 7.6 GB of memory for the 30 minutes of the limit. In three of them the tests had already finished and a single file hung for 25 minutes or more.&lt;/p&gt;

&lt;p&gt;Since 0.8.0, every 5 seconds the daemon looks at what each job is doing: CPU time, disk I/O, page faults, number of processes and log bytes. A job with no progress at all for &lt;code&gt;max(5 min, 3 × its usual duration)&lt;/code&gt; shows up as &lt;code&gt;STALLED&lt;/code&gt; in &lt;code&gt;sluice status&lt;/code&gt;, and the agent gets the warning in the &lt;code&gt;verify&lt;/code&gt; progress. Sluice never kills it: the &lt;em&gt;gate&lt;/em&gt;'s &lt;code&gt;timeout&lt;/code&gt; is still the only limit. I decided it this way so there is no false positive that costs a good job. A &lt;em&gt;gate&lt;/em&gt; that is meant to stay still (a &lt;code&gt;watch&lt;/code&gt;, a server) can set &lt;code&gt;stall_timeout = "off"&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;The first night: 0 hangs and 0 false warnings across 177 jobs. The longest silence of any job was 20 seconds.&lt;/p&gt;

&lt;h2&gt;
  
  
  What if I can't touch the repository's hooks?
&lt;/h2&gt;

&lt;p&gt;It happened to me in a client's Angular repository that uses husky. The hooks belong to the client and their team, so I couldn't rewrite them, and husky prepends its own &lt;code&gt;PATH&lt;/code&gt;: each commit's tests ran outside the queue and the cache. Minutes per commit, competing with everything else.&lt;/p&gt;

&lt;p&gt;Since 0.7.0, Sluice can be the entry point for your clone's hooks without modifying the repository:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;sluice hooks on       &lt;span class="c"&gt;# or, when configuring: sluice init --hooks entry&lt;/span&gt;
sluice hooks status   &lt;span class="c"&gt;# which hook goes through the queue and which is delegated, and why&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;on&lt;/code&gt; points &lt;code&gt;core.hooksPath&lt;/code&gt; to a hooks directory inside the clone's git directory, from a file included in its configuration, so husky's write on each install doesn't displace it. &lt;code&gt;off&lt;/code&gt; removes it, and if the &lt;code&gt;sluice&lt;/code&gt; binary is missing, the repository's hooks keep working.&lt;/p&gt;

&lt;p&gt;The design rule is: either I understand it entirely, or I run it untouched. Before writing it I read the source code of husky, lefthook and pre-commit. A hook that Sluice fully understands runs its commands as queue jobs, in the manager's order: read-only ones, like tests or linters, go to the cache, and those that can change files, like &lt;code&gt;lint-staged&lt;/code&gt;, always run. Any other hook runs exactly as before.&lt;/p&gt;

&lt;p&gt;In a repository without &lt;code&gt;.sluice.toml&lt;/code&gt;, those hook units become the &lt;code&gt;verify&lt;/code&gt; &lt;em&gt;gates&lt;/em&gt;, with the same cache inputs: a &lt;code&gt;verify&lt;/code&gt; before &lt;code&gt;git commit&lt;/code&gt; turns the commit hook into a cache answer.&lt;/p&gt;

&lt;h2&gt;
  
  
  How does an agent use it without hitting the shell timeout?
&lt;/h2&gt;

&lt;p&gt;Through MCP. &lt;code&gt;sluice mcp&lt;/code&gt; exposes a &lt;code&gt;verify&lt;/code&gt; tool that blocks until the &lt;em&gt;gates&lt;/em&gt; finish and sends a progress notification every 15 seconds. Claude Code, for example, only cuts an MCP call if its inactivity window (30 minutes by default) passes with no response or progress, so the agent waits as long as needed, without the shell's limit.&lt;/p&gt;

&lt;p&gt;In Claude Code, the rest of the plugin steers the agent that way: a &lt;em&gt;skill&lt;/em&gt; that teaches it to use &lt;code&gt;verify&lt;/code&gt; and the merge queue, and a &lt;em&gt;guard&lt;/em&gt; that rewrites the &lt;em&gt;gates&lt;/em&gt;' commands to &lt;code&gt;sluice run &amp;lt;gate&amp;gt; -v&lt;/code&gt; and heavy ones (builds, test runners) to &lt;code&gt;sluice exec -- ...&lt;/code&gt;, so they share the budget. With other agents, the &lt;code&gt;AGENTS.md&lt;/code&gt; block carries the same instructions as the skill. And if an agent commits with a tree that isn't in the cache, the hook rewired by &lt;code&gt;sluice init&lt;/code&gt; answers immediately with exit code 3 and tells it to use &lt;code&gt;verify&lt;/code&gt;, instead of waiting inside &lt;code&gt;git commit&lt;/code&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  How do I integrate the branches of several agents?
&lt;/h2&gt;

&lt;p&gt;With the local merge queue. An agent finishes its branch, passes &lt;code&gt;verify&lt;/code&gt;, commits and enqueues it. The daemon combines the queued branches onto the target in a disposable &lt;em&gt;worktree&lt;/em&gt; (a "train") and runs the &lt;em&gt;gates&lt;/em&gt; once on the combined tree, with the same cache and the same budget:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;sluice queue enqueue           &lt;span class="c"&gt;# the agent does this, or you&lt;/span&gt;
sluice queue status            &lt;span class="c"&gt;# the plan: trains, conflicts and what is ready&lt;/span&gt;
sluice queue approve &amp;lt;train&amp;gt;   &lt;span class="c"&gt;# you do this&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;By default, nothing is pushed until a person approves the train: the daemon rejects an agent's approval, over MCP or from the terminal, and the Claude Code plugin blocks it too. You can allow it explicitly in your personal configuration (&lt;code&gt;allow_agent_approval = true&lt;/code&gt;); a repository can't turn it on by itself. Even so, two cases remain human-only: a train that changes the project's own verification configuration and landing through a &lt;em&gt;pull request&lt;/em&gt;. If your target branch is protected and only accepts &lt;em&gt;pull requests&lt;/em&gt;, &lt;code&gt;[queue] land = "pull-request"&lt;/code&gt; pushes the verified result to a &lt;code&gt;sluice/train/&amp;lt;id&amp;gt;&lt;/code&gt; branch and, on approval, opens the &lt;em&gt;pull request&lt;/em&gt; with your own &lt;code&gt;gh&lt;/code&gt;. Sluice never does the merge.&lt;/p&gt;

&lt;h2&gt;
  
  
  How did I build it?
&lt;/h2&gt;

&lt;p&gt;With AI agents, and verified with Sluice itself: every commit of the project goes through its own queue and its own cache. The first commit is from October 22 and 0.8.0 came out on the 28th: from 0.1.0 to 0.8.0 in a week, with about 190 commits, about 105,000 lines of Rust and 25 architecture decisions (ADRs) documented in the repository.&lt;/p&gt;

&lt;p&gt;Each big change followed the same cycle: analysis of the code and of real data from the two machines, proposals with their risks, my decision recorded in an ADR, implementation in waves with agents, and review. Before each version, CI on 7 combinations: Ubuntu 22.04 and 24.04, Debian, Fedora, Alpine, ARM and the minimum git version. Several times the review found bugs the tests didn't see, and CI uncovered problems that only existed on Alpine or Fedora. And almost every version was born from a problem I saw using Sluice daily: memory in 0.6.0, hooks in 0.7.0 and the stuck queue in 0.8.0.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try it
&lt;/h2&gt;

&lt;p&gt;Install the binary and connect your agent as above, and in your repository:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;sluice doctor
sluice init &lt;span class="nt"&gt;--dry-run&lt;/span&gt;
sluice init
sluice status
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The code, the documentation and the 25 ADRs are at &lt;a href="https://github.com/josegarridodigio/sluice" rel="noopener noreferrer"&gt;github.com/josegarridodigio/sluice&lt;/a&gt;. If something doesn't work for you, &lt;code&gt;sluice doctor --bundle&lt;/code&gt; generates a diagnostic bundle, with sensitive data removed, to attach to an &lt;em&gt;issue&lt;/em&gt;.&lt;/p&gt;

</description>
      <category>rust</category>
      <category>ai</category>
      <category>devtools</category>
      <category>claudecode</category>
    </item>
    <item>
      <title>I set up REA and tried it on YouTube: what it gets right</title>
      <dc:creator>José Antonio Garrido</dc:creator>
      <pubDate>Wed, 28 Oct 2026 07:00:04 +0000</pubDate>
      <link>https://dev.to/yeyo11/i-set-up-rea-and-tried-it-on-youtube-what-it-gets-right-5gi3</link>
      <guid>https://dev.to/yeyo11/i-set-up-rea-and-tried-it-on-youtube-what-it-gets-right-5gi3</guid>
      <description>&lt;p&gt;I wanted to know what YouTube's player really does when you press play: what it downloads, what it sends while you watch, and how it decides the quality. The browser's DevTools show you each request, but reading hundreds of requests and 13 MB of minified JavaScript by hand is not a plan. So I set up &lt;a href="https://github.com/morluto/rea" rel="noopener noreferrer"&gt;REA&lt;/a&gt; (Reverse Engineer Anything) with Claude Code and asked it those three questions.&lt;/p&gt;

&lt;p&gt;REA is an open-source toolkit (MIT licence) that lets an agent inspect software without its source code: native binaries, Electron apps, Android APKs, WebAssembly and web pages. It works as a command line and as an MCP server. The official repository is &lt;code&gt;morluto/rea&lt;/code&gt; and the npm package is &lt;code&gt;rea-agents&lt;/code&gt;; several sites with similar names are not the project's. I use version 6.8.0, the latest on npm as I write this.&lt;/p&gt;

&lt;p&gt;I checked every one of REA's answers another way: a network log of my own over the DevTools protocol, and the player's own statistics panel. Where REA is right I say so, and where it falls short too.&lt;/p&gt;

&lt;h2&gt;
  
  
  What you need
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Node.js 24 (&lt;code&gt;npx&lt;/code&gt; comes with it).&lt;/li&gt;
&lt;li&gt;Claude Code, if you want to use it from the agent.&lt;/li&gt;
&lt;li&gt;Google Chrome.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Nothing else.&lt;/strong&gt; Ghidra, IDA or Hopper are only needed for native binaries. For a web page, REA brings everything it uses.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Install REA in Claude Code
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;setup&lt;/code&gt; shows you what it is going to change first, then applies it. Pin the version in every command, so everything you do is reproducible:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npx &lt;span class="nt"&gt;-y&lt;/span&gt; rea-agents@6.8.0 setup &lt;span class="nt"&gt;--client&lt;/span&gt; claude_code &lt;span class="nt"&gt;--dry-run&lt;/span&gt;
npx &lt;span class="nt"&gt;-y&lt;/span&gt; rea-agents@6.8.0 setup &lt;span class="nt"&gt;--client&lt;/span&gt; claude_code &lt;span class="nt"&gt;--yes&lt;/span&gt;
npx &lt;span class="nt"&gt;-y&lt;/span&gt; rea-agents@6.8.0 doctor &lt;span class="nt"&gt;--client&lt;/span&gt; claude_code
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Frinnfa2jrzw2i0u6h3po.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Frinnfa2jrzw2i0u6h3po.png" alt="The setup plan, applying it, and doctor reporting healthy" width="800" height="505"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The plan has two actions: register the MCP server in &lt;code&gt;~/.claude.json&lt;/code&gt; as &lt;code&gt;npx -y rea-agents@6.8.0 mcp&lt;/code&gt;, and install REA's skill in &lt;code&gt;~/.claude/skills/&lt;/code&gt;. Afterwards, &lt;code&gt;doctor&lt;/code&gt; reports &lt;code&gt;healthy: true&lt;/code&gt;. It will tell you Ghidra, IDA, Hopper and JADX are missing: they are engines for other kinds of target and do not affect what follows.&lt;/p&gt;

&lt;p&gt;I did it with an empty &lt;code&gt;HOME&lt;/code&gt;, so as not to touch my own configuration and to see what you would see from scratch. If you would rather have REA in one project only, put this in its &lt;code&gt;.mcp.json&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"mcpServers"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"rea"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"command"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"npx"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"args"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"-y"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"rea-agents@6.8.0"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"mcp"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Open a Chrome that REA can observe
&lt;/h2&gt;

&lt;p&gt;REA watches the browser through the DevTools protocol. Open a Chrome with its own profile and the debugging port listening on your machine only:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;google-chrome &lt;span class="nt"&gt;--remote-debugging-address&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;127.0.0.1 &lt;span class="nt"&gt;--remote-debugging-port&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;9333 &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--user-data-dir&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="si"&gt;$(&lt;/span&gt;&lt;span class="nb"&gt;mktemp&lt;/span&gt; &lt;span class="nt"&gt;-d&lt;/span&gt;&lt;span class="si"&gt;)&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt; &lt;span class="nt"&gt;--mute-audio&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A separate profile matters: whoever reaches that port controls the browser, so never use your everyday one. Open a video and reject the cookies. I used two: "Me at the zoo" (the first video on YouTube, 19 seconds) and &lt;em&gt;Big Buck Bunny&lt;/em&gt;, by the Blender Foundation (CC BY licence), which is long enough and comes in several qualities.&lt;/p&gt;

&lt;p&gt;Rejecting the cookies is not optional: while the notice is open, the video stops at 2 seconds and there is nothing to observe.&lt;/p&gt;

&lt;p&gt;With the browser ready, REA can see it:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npx &lt;span class="nt"&gt;-y&lt;/span&gt; rea-agents@6.8.0 list-browser-targets http://127.0.0.1:9333
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Question 1: what the page loads before the video starts
&lt;/h2&gt;

&lt;p&gt;The tool for this is &lt;code&gt;capture-browser-scenario&lt;/code&gt;: REA navigates to the URL you give it, runs the steps you declare and records the network. This is the scenario I used:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"browser"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"mode"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"connect"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"cdp_endpoint"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"http://127.0.0.1:9333"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"target_id"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"&amp;lt;the id from list-browser-targets&amp;gt;"&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;},&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"start_url"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"url"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"https://www.youtube.com/watch?v=jNQXAC9IVRw"&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;},&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"environment"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"service_workers"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"allow"&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;},&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"actions"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"step_id"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"player"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"action"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"wait_for"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"locator"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"kind"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"css"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"selector"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"#movie_player video"&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;},&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"state"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"attached"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"timeout_ms"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="mi"&gt;20000&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;},&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"step_id"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"watch"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"action"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"wait_for_timeout"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"duration_ms"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="mi"&gt;25000&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"capture"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"at_end"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"url"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"screenshot"&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"events"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"network"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"page-errors"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npx &lt;span class="nt"&gt;-y&lt;/span&gt; rea-agents@6.8.0 capture-browser-scenario scenario.json &lt;span class="nt"&gt;--format&lt;/span&gt; json &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; scenario-out.json
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The &lt;code&gt;"service_workers": "allow"&lt;/code&gt; line is not decoration. Without it REA refuses: YouTube registers a service worker and, by default, REA does not observe pages controlled by one. The error says exactly that and tells you what to change.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What REA saw.&lt;/strong&gt; 81 requests in 28 seconds (85 in 29 when I repeated it on a clean profile). Before the first video request, which goes out at 1.3 seconds, the page asks for:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;the &lt;code&gt;/watch&lt;/code&gt; HTML;&lt;/li&gt;
&lt;li&gt;17 thumbnails from &lt;code&gt;i.ytimg.com&lt;/code&gt;;&lt;/li&gt;
&lt;li&gt;the player (&lt;code&gt;/s/player/…/base.js&lt;/code&gt;) and the site's modules;&lt;/li&gt;
&lt;li&gt;three polyfills (&lt;code&gt;web-animations-next-lite&lt;/code&gt;, &lt;code&gt;webcomponents-sd&lt;/code&gt;, &lt;code&gt;intersection-observer&lt;/code&gt;);&lt;/li&gt;
&lt;li&gt;the stylesheets and the fonts.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Right with the first video request come the player's optional modules: &lt;code&gt;offline.js&lt;/code&gt;, &lt;code&gt;remote.js&lt;/code&gt;, &lt;code&gt;miniplayer.js&lt;/code&gt;, &lt;code&gt;captions.js&lt;/code&gt;, &lt;code&gt;endscreen.js&lt;/code&gt; and &lt;code&gt;annotations_module.js&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The check.&lt;/strong&gt; On another load of the same video I logged the network myself, over the DevTools protocol. The same paths come out in the same order, tenths of a second apart; only a few recommendation thumbnails differ. And a detail I did not expect: the whole 19 seconds of video arrive in &lt;strong&gt;a single &lt;code&gt;POST&lt;/code&gt; request&lt;/strong&gt; to &lt;code&gt;*.googlevideo.com/videoplayback&lt;/code&gt;, 480 KB of it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How heavy it is.&lt;/strong&gt; With &lt;code&gt;analyze-web-bundle&lt;/code&gt;, REA counts 50 scripts and 13.7 MB of JavaScript on the page. Two of them take almost all of it: the site's core (9.7 MB) and the player, &lt;code&gt;base.js&lt;/code&gt; (2.6 MB). I downloaded both separately with &lt;code&gt;curl&lt;/code&gt; and they match byte for byte, with the same hash; compressed, they travel as 2 MB and 0.7 MB.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Verdict:&lt;/strong&gt; REA gets it right. Its inventory matches the browser's.&lt;/p&gt;

&lt;h2&gt;
  
  
  Question 2: what the browser sends while you watch
&lt;/h2&gt;

&lt;p&gt;I repeated the scenario with &lt;em&gt;Big Buck Bunny&lt;/em&gt; and 90 seconds of playback, and compared it with my log again. They match request for request. While you watch, the browser does this:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;POST *.googlevideo.com/videoplayback&lt;/code&gt;&lt;/strong&gt;: every 3 to 9 seconds, while the buffer fills. Each response brings 0.5 to 1.1 MB of video, and each request carries 1.7 to 2 KB from the browser.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;POST /api/stats/watchtime&lt;/code&gt;&lt;/strong&gt;: every 10 seconds (at 10, 20 and 30 s).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;POST /api/stats/qoe&lt;/code&gt;&lt;/strong&gt;: at the start, then every 10 to 30 seconds.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;POST /api/stats/playback&lt;/code&gt;&lt;/strong&gt; and &lt;strong&gt;&lt;code&gt;GET /ptracking&lt;/code&gt;&lt;/strong&gt;: once, at the start.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;POST /api/stats/atr&lt;/code&gt;&lt;/strong&gt;: once, at 2 seconds.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;POST /youtubei/v1/log_event&lt;/code&gt;&lt;/strong&gt;: a couple of times while loading.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;By 40 seconds in, the player already had 55 seconds of video downloaded ahead.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What REA adds.&lt;/strong&gt; With &lt;code&gt;observe-web-execution&lt;/code&gt;, REA gives each request's call stack. The &lt;code&gt;qoe&lt;/code&gt; report comes from the player, from a function called &lt;code&gt;reportStats&lt;/code&gt; in &lt;code&gt;base.js&lt;/code&gt;. The &lt;code&gt;watchtime&lt;/code&gt; one comes from the site's core, from &lt;code&gt;sendThenWrite&lt;/code&gt;. In that capture, taken while I released the connection in question 3, both URLs carried &lt;code&gt;fmt=397&lt;/code&gt; and &lt;code&gt;afmt=251&lt;/code&gt;. They are the same identifiers the player's "Stats for nerds" panel (right-click on the video) shows next to the codecs: &lt;code&gt;av01 (397)&lt;/code&gt; at 480p, &lt;code&gt;av01 (394)&lt;/code&gt; at 144p and &lt;code&gt;opus (251)&lt;/code&gt; for the audio.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Verdict:&lt;/strong&gt; REA gets it right, and the call stack adds something the network tab does not give you at a glance.&lt;/p&gt;

&lt;h2&gt;
  
  
  Question 3: how it chooses the quality
&lt;/h2&gt;

&lt;p&gt;This was the hard one. To force a change, I limited the connection to 300 kbit/s over the DevTools protocol (&lt;code&gt;Network.emulateNetworkConditions&lt;/code&gt;) before opening the video. Halfway through the test I released it.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fg6bkn1pdh05yop31juwb.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fg6bkn1pdh05yop31juwb.png" alt="Resolution on screen during the test: 480p, 144p with the connection limited, and 480p again 22 seconds after releasing it" width="800" height="393"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;This is what the browser measured, sampling the resolution every 2 seconds:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;With the connection limited&lt;/strong&gt;, the first 2 seconds play at 480p. At 6 seconds into the video the player drops to 144p.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;When the connection is released&lt;/strong&gt;, the player starts asking for 480p &lt;em&gt;at that very moment&lt;/em&gt;, and its buffer jumps from 22 to 59 seconds.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;But the picture stays at 144p&lt;/strong&gt; until what was already downloaded has played. In this test it took 22 seconds. In another, 16. In a third it was still at 144p 32 seconds later, when the test ended.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvttddtwv17qwr4t36wyb.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvttddtwv17qwr4t36wyb.png" alt="Stats for nerds with the connection limited: current resolution 256x144, optimal 854x480, 139 kbps. Big Buck Bunny © Blender Foundation, CC BY 3.0" width="799" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Feeir3otdm9isqc8piav3.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Feeir3otdm9isqc8piav3.png" alt="Stats for nerds after releasing the connection: 854x480, 12,511 kbps and 60 seconds of buffer. Big Buck Bunny © Blender Foundation, CC BY 3.0" width="799" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The panel confirms it: &lt;code&gt;256x144&lt;/code&gt; against an optimal &lt;code&gt;854x480&lt;/code&gt; at 139 kbps, then &lt;code&gt;854x480&lt;/code&gt; at 12,511 kbps with 60 seconds of buffer. (My browser showed the panel in Spanish, as «Estadísticas avanzadas».) Its "Mystery Text" line says "SABR", and the video arrives in &lt;code&gt;POST&lt;/code&gt; requests that carry 1.7 to 2 KB from the browser each.&lt;/p&gt;

&lt;p&gt;And an earlier experiment, the other way round: if you limit the connection &lt;em&gt;after&lt;/em&gt; the buffer has filled, the quality does not drop. With 55 seconds already downloaded, the rest of the test (more than 40 seconds) played at 480p.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What REA did.&lt;/strong&gt; I asked it where that decision lives in the code, and it did not get there.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;analyze-web-bundle&lt;/code&gt;&lt;/strong&gt; analyses the JavaScript without running it. With its default settings (30 seconds per script), it ran out of time on exactly the two scripts that matter: the player and the site's core, 12.4 of the 13.7 MB. I repeated it with 10 minutes per script and 6 GB of memory: 20 minutes and 4.6 GB later, the same result.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;observe-web-execution&lt;/code&gt;&lt;/strong&gt; measures which functions run during a time window. I started it a few seconds before releasing the connection, with a 15-second window: in that time 1,022 of the player's functions ran. Almost all have minified names (&lt;code&gt;uHa&lt;/code&gt;, &lt;code&gt;pz&lt;/code&gt;, &lt;code&gt;Dz&lt;/code&gt;…). The only readable ones are browser APIs, such as &lt;code&gt;appendBuffer&lt;/code&gt;, which puts the pieces of video into the buffer, and &lt;code&gt;getPlaybackQuality&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ffo73zx4hbt5r6wc8x5h0.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ffo73zx4hbt5r6wc8x5h0.png" alt="analyze-web-bundle on YouTube: the two large scripts are left unanalysed with 30 seconds and with 10 minutes per script" width="799" height="367"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Verdict:&lt;/strong&gt; REA did not find where the quality is decided. What I know about question 3, the browser measured.&lt;/p&gt;

&lt;h2&gt;
  
  
  Use it from Claude Code
&lt;/h2&gt;

&lt;p&gt;With the MCP server registered, you ask Claude Code in plain language. I tried it three times with &lt;code&gt;claude -p&lt;/code&gt;, and the result depended a lot on the prompt:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;A prompt that does not name the tool&lt;/strong&gt;, with at most 12 turns. Claude used &lt;code&gt;inspect_web_page&lt;/code&gt;, but REA's answer was 1.17 million characters long. That exceeds Claude Code's output limit for an MCP tool, so it saves it to a file, and the agent spent its 12 turns reading it without answering. Along the way it tried to pass &lt;code&gt;https://*.googlevideo.com&lt;/code&gt; as an allowed origin, and REA refused: it only accepts exact origins, and the video servers change name every session.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The same prompt, again.&lt;/strong&gt; This time it chose &lt;code&gt;observe_web_session&lt;/code&gt;, which only records the page's navigation, not its requests. It answered, rightly, that it could not tell me anything.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A prompt that names the tool&lt;/strong&gt;, its parameters, and to read the file with &lt;code&gt;jq&lt;/code&gt;. Seven turns and 50 seconds.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F99keqyr4yrnwxu54gorc.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F99keqyr4yrnwxu54gorc.png" alt="Claude Code with REA: the answer separates what was observed from its interpretation" width="800" height="785"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;In those 10 seconds the page made no request to &lt;code&gt;www.youtube.com&lt;/code&gt;. REA filtered 3 to other origins because they were not allowed, and Claude says so, separating what it observed from its interpretation. The lesson: tell it which tool to use and which origins, and be ready to read large results from a file.&lt;/p&gt;

&lt;h2&gt;
  
  
  What REA gets right and what it does not
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;It gets&lt;/strong&gt; the network inventory right: it matched my log request for request in every test.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;It adds&lt;/strong&gt; each request's call stack, which tells you which script and which function sent it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;It warns well.&lt;/strong&gt; Every output lists its limits, for instance that observation starts when it connects or which requests it filtered by origin, and its errors say what to change.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;It does not get through&lt;/strong&gt; static analysis of a bundle like YouTube's: the two scripts that matter are left unanalysed, even with 10 minutes per script.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;It gives no useful names&lt;/strong&gt; in minified code: it knows which functions ran, not what they do.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;It asks for judgement from the agent.&lt;/strong&gt; Picking the wrong tool (navigation only) or asking for a million-character result are easy mistakes.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Repeat it
&lt;/h2&gt;

&lt;p&gt;With Chrome open as above and a video playing:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npx &lt;span class="nt"&gt;-y&lt;/span&gt; rea-agents@6.8.0 setup &lt;span class="nt"&gt;--client&lt;/span&gt; claude_code &lt;span class="nt"&gt;--yes&lt;/span&gt;
npx &lt;span class="nt"&gt;-y&lt;/span&gt; rea-agents@6.8.0 doctor &lt;span class="nt"&gt;--client&lt;/span&gt; claude_code
npx &lt;span class="nt"&gt;-y&lt;/span&gt; rea-agents@6.8.0 list-browser-targets http://127.0.0.1:9333
npx &lt;span class="nt"&gt;-y&lt;/span&gt; rea-agents@6.8.0 capture-browser-scenario scenario.json &lt;span class="nt"&gt;--format&lt;/span&gt; json &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; scenario-out.json
npx &lt;span class="nt"&gt;-y&lt;/span&gt; rea-agents@6.8.0 observe-web-execution http://127.0.0.1:9333 &amp;lt;target_id&amp;gt; &lt;span class="nt"&gt;--observation-ms&lt;/span&gt; 15000 &lt;span class="nt"&gt;--format&lt;/span&gt; json &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; execution.json
npx &lt;span class="nt"&gt;-y&lt;/span&gt; rea-agents@6.8.0 analyze-web-bundle http://127.0.0.1:9333 &amp;lt;target_id&amp;gt; &lt;span class="nt"&gt;--observation-ms&lt;/span&gt; 3000 &lt;span class="nt"&gt;--format&lt;/span&gt; json &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; bundle.json
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The outputs are large JSON; &lt;code&gt;jq&lt;/code&gt; is your friend. For example, &lt;code&gt;jq '.normalized_result.events.items | length' scenario-out.json&lt;/code&gt; counts the network events.&lt;/p&gt;

&lt;h2&gt;
  
  
  Limits
&lt;/h2&gt;

&lt;p&gt;All of this is observing what your browser already downloads and already sends, the same you would see in DevTools, and explaining it. I did not touch anyone's session, the ads, or the video's protections, and I downloaded no videos. If you analyse a site, respect its terms of use.&lt;/p&gt;

</description>
      <category>claudecode</category>
      <category>mcp</category>
      <category>reverseengineering</category>
      <category>webdev</category>
    </item>
    <item>
      <title>Shipcast: launch your GitHub projects without writing the announcement ten times</title>
      <dc:creator>José Antonio Garrido</dc:creator>
      <pubDate>Sun, 25 Oct 2026 04:09:21 +0000</pubDate>
      <link>https://dev.to/yeyo11/shipcast-launch-your-github-projects-without-writing-the-announcement-ten-times-4p7c</link>
      <guid>https://dev.to/yeyo11/shipcast-launch-your-github-projects-without-writing-the-announcement-ten-times-4p7c</guid>
      <description>&lt;p&gt;You publish a release and then spend an afternoon on the same announcement: a blog post, a dev.to copy, a Bluesky post, a Mastodon post, an Instagram carousel, a newsletter issue, a Show HN title. Each one has its own length limit and its own tone, and the easiest mistake is to promise in one of them something the code does not do yet.&lt;/p&gt;

&lt;p&gt;Shipcast does that work from the release. It reads the project's &lt;strong&gt;code&lt;/strong&gt;, not just its README, writes a piece for each channel, and publishes each one once you approve it. I used it to launch &lt;a href="https://github.com/yeyo11/claudio" rel="noopener noreferrer"&gt;claudio&lt;/a&gt; v0.9.0, and this article is part of its own launch.&lt;/p&gt;

&lt;h2&gt;
  
  
  What you get
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;The article on your blog in English and Spanish, each with its own URL.&lt;/li&gt;
&lt;li&gt;Canonical copies on dev.to (and Hashnode, built but not yet tested live).&lt;/li&gt;
&lt;li&gt;Posts on Bluesky and Mastodon, and an Instagram carousel with its story and a comment.&lt;/li&gt;
&lt;li&gt;A newsletter issue per language through Brevo.&lt;/li&gt;
&lt;li&gt;Ready-to-paste Show HN and Product Hunt drafts: neither has an API to post through, so Shipcast never posts them.&lt;/li&gt;
&lt;li&gt;Telegram and Discord connectors, plus the numbers of each channel on the launch's page.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Opt in per repo
&lt;/h2&gt;

&lt;p&gt;A project turns launches on with &lt;code&gt;.github/launch.yml&lt;/code&gt;. Each channel has a mode:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;enabled&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
&lt;span class="na"&gt;brand&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;personal&lt;/span&gt;
&lt;span class="na"&gt;language&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;en&lt;/span&gt;

&lt;span class="na"&gt;publishing&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;blog&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;approval&lt;/span&gt;
  &lt;span class="na"&gt;devto&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;approval&lt;/span&gt;
  &lt;span class="na"&gt;bluesky&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;approval&lt;/span&gt;
  &lt;span class="na"&gt;hackerNews&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;manual&lt;/span&gt;

&lt;span class="na"&gt;assets&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;demo&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;docs/media/tour.gif&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;auto&lt;/code&gt; publishes as soon as the pack is generated, &lt;code&gt;approval&lt;/code&gt; publishes when you merge the drafts, &lt;code&gt;manual&lt;/code&gt; leaves a draft you post yourself, and &lt;code&gt;off&lt;/code&gt; skips the channel. Hacker News and Product Hunt refuse any mode other than &lt;code&gt;manual&lt;/code&gt; or &lt;code&gt;off&lt;/code&gt;. The schema is strict: a misspelt key is an error that points at its line instead of a setting silently ignored.&lt;/p&gt;

&lt;h2&gt;
  
  
  Check the repo first
&lt;/h2&gt;

&lt;p&gt;Before spending any AI budget, the pre-flight check confirms the repo is ready:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;pnpm shipcast preflight owner/repo
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;It checks that there is a published release, a valid and enabled &lt;code&gt;launch.yml&lt;/code&gt;, a license GitHub recognises, a README and a demo that answers. Each line prints &lt;code&gt;ok&lt;/code&gt;, &lt;code&gt;warn&lt;/code&gt; or &lt;code&gt;FAIL&lt;/code&gt;, and &lt;code&gt;launch&lt;/code&gt; refuses to start while a required check fails.&lt;/p&gt;

&lt;h2&gt;
  
  
  Trigger a launch
&lt;/h2&gt;

&lt;p&gt;Two ways. Manually, for the latest release or a given tag:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;pnpm shipcast launch owner/repo &lt;span class="nt"&gt;--ref&lt;/span&gt; v1.2.0
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Or let the engine watch your account:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;pnpm shipcast watch &lt;span class="nt"&gt;--interval&lt;/span&gt; 300
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;watch&lt;/code&gt; polls your public GitHub events (there are no webhooks, so nothing on your machine is exposed), drafts each new release, publishes it once its pull request is merged and reads the metrics every six hours. The interval cannot go below 60 seconds, which is what GitHub asks of event pollers.&lt;/p&gt;

&lt;h2&gt;
  
  
  How it works
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Analyse.&lt;/strong&gt; Claude, through &lt;a href="https://github.com/yeyo11/claudio" rel="noopener noreferrer"&gt;claudio&lt;/a&gt;, reads the repository and separates what is implemented from what is only planned or only claimed by the docs. Only the implemented part is presented as working.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Generate.&lt;/strong&gt; The result is one structured content pack validated against a JSON Schema: the article in each language and a piece for each channel within its limits. Shipcast also builds the launch image, the Instagram carousel and story, and a cover in your blog's style when the project has none.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Approve.&lt;/strong&gt; The drafts arrive as a pull request in your launches repo, which is also your blog's source. Read and edit them in the app or on GitHub; merging publishes.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Publish once.&lt;/strong&gt; A SQLite registry records every launch and every channel. Re-running a workflow or publishing a minor version does not repeat a campaign, and a channel that failed for good can be retried:
&lt;/li&gt;
&lt;/ol&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;pnpm shipcast publish &lt;span class="nt"&gt;--retry&lt;/span&gt; bluesky
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;pnpm shipcast status&lt;/code&gt; lists the latest launches, where each stands and which channels are configured.&lt;/p&gt;

&lt;h2&gt;
  
  
  The app
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;pnpm app
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The web app has Launches (where each one went and what is waiting for you), a review page (edit, approve, retry), Launch a repo, Write, and Channels. Write takes an article in your own words, translates it, writes the piece for each channel and publishes it the same way. Channels lists every network with its accounts per brand, checks each credential, runs OAuth for Mastodon and Instagram and keeps secrets in your operating system's keychain. Sign-in is with GitHub, limited to the logins you allow.&lt;/p&gt;

&lt;p&gt;The personal and company brands have their own accounts, tone and language, and a launch only uses its own brand's accounts.&lt;/p&gt;

&lt;h2&gt;
  
  
  Quick start
&lt;/h2&gt;

&lt;p&gt;You need Node 24 and pnpm, &lt;a href="https://github.com/yeyo11/claudio" rel="noopener noreferrer"&gt;claudio&lt;/a&gt; as the AI provider (the repo's &lt;code&gt;docker-compose.yml&lt;/code&gt; starts it), a launches repo with an Astro blog that accepts the articles (&lt;a href="https://github.com/yeyo11/shipcast/blob/main/docs/launches-repo.md" rel="noopener noreferrer"&gt;docs/launches-repo.md&lt;/a&gt; describes the contract), and an account on each network you want. On Linux the keychain needs &lt;code&gt;libsecret-tools&lt;/code&gt;, and the demo video needs ffmpeg.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;pnpm &lt;span class="nb"&gt;install
cp&lt;/span&gt; .env.example .env              &lt;span class="c"&gt;# fill in what you use&lt;/span&gt;
pnpm shipcast preflight owner/repo
pnpm shipcast launch owner/repo   &lt;span class="c"&gt;# or: pnpm app&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A network or source without its variables is left out, and &lt;code&gt;pnpm shipcast status&lt;/code&gt; shows what is on.&lt;/p&gt;

&lt;h2&gt;
  
  
  What comes next
&lt;/h2&gt;

&lt;p&gt;The next phase covers other AI providers besides claudio, a GitHub Action mode, a one-command install, and the setup of the company brand. The test of this release is to launch Shipcast with Shipcast on every connected channel.&lt;/p&gt;

&lt;p&gt;The code is MIT-licensed at &lt;a href="https://github.com/yeyo11/shipcast" rel="noopener noreferrer"&gt;github.com/yeyo11/shipcast&lt;/a&gt;. Issues are welcome, and please open one before a pull request.&lt;/p&gt;

</description>
      <category>github</category>
      <category>automation</category>
      <category>ai</category>
      <category>opensource</category>
    </item>
    <item>
      <title>Claudio: run Claude Code as a service</title>
      <dc:creator>José Antonio Garrido</dc:creator>
      <pubDate>Sat, 24 Oct 2026 23:10:56 +0000</pubDate>
      <link>https://dev.to/yeyo11/claudio-run-claude-code-as-a-service-69m</link>
      <guid>https://dev.to/yeyo11/claudio-run-claude-code-as-a-service-69m</guid>
      <description>&lt;p&gt;Claude Code lives in a terminal. That is fine until you want to start a chat from your phone, check on an agent that is still working while you are away from the desk, or run five of them in parallel without losing track of which one needs an answer. I built Claudio to cover that gap: it runs Claude Code as a service.&lt;/p&gt;

&lt;p&gt;This post covers what Claudio is, how it talks to Claude Code and how to install it.&lt;/p&gt;

&lt;h2&gt;
  
  
  What you get
&lt;/h2&gt;

&lt;p&gt;Claudio puts the Claude Code CLI behind a REST API and a web UI. The same server also backs a Linux desktop app and an installable web app for your phone. Everything runs on your machine or your server, with your own Claude login.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Chats you can start, stream and answer from a browser or over HTTP.&lt;/li&gt;
&lt;li&gt;Orchestrations: a graph of tasks run by parallel workers, each in its own git worktree.&lt;/li&gt;
&lt;li&gt;Several Claude accounts, with work moving to the one that still has quota.&lt;/li&gt;
&lt;li&gt;A review screen for what the agents changed.&lt;/li&gt;
&lt;li&gt;Projects with a task board and a team of agents.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;I will go through them one at a time.&lt;/p&gt;

&lt;h2&gt;
  
  
  The one rule: only the interface the CLI ships for programs
&lt;/h2&gt;

&lt;p&gt;Claudio does not scrape the terminal, call undocumented endpoints or log in a second time on its own. It reaches Claude Code through the CLI's flags, its stream protocol and the files it writes. &lt;a href="https://github.com/yeyo11/claudio/blob/main/docs/cli-surfaces.md" rel="noopener noreferrer"&gt;docs/cli-surfaces.md&lt;/a&gt; lists every surface in use, one row per need. For example:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Run / continue a conversation  claude -p --input-format stream-json --output-format stream-json
Auth status                    claude auth status --json
Session history                $CLAUDE_CONFIG_DIR/projects/*/*.jsonl
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The practical consequence is a ceiling: what the CLI cannot do, Claudio cannot do. Web artifacts and claude.ai chat memory have no CLI surface, so Claudio does not touch them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Chats over HTTP
&lt;/h2&gt;

&lt;p&gt;A chat is one long-lived &lt;code&gt;claude&lt;/code&gt; process fed over stdin, with &lt;code&gt;--resume&lt;/code&gt; when the process is gone. You can start one from the UI or from the API:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;curl &lt;span class="nt"&gt;-X&lt;/span&gt; POST http://localhost:8797/api/chats &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;-H&lt;/span&gt; &lt;span class="s1"&gt;'Content-Type: application/json'&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;-d&lt;/span&gt; &lt;span class="s1"&gt;'{"prompt": "Add a unit test for parseDuration", "cwd": "/workspace/my-app"}'&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The request also accepts &lt;code&gt;worktree&lt;/code&gt; (run inside a new git worktree of that name) and &lt;code&gt;jsonSchema&lt;/code&gt; (structured output). From there you have &lt;code&gt;POST /api/chats/:id/messages&lt;/code&gt;, &lt;code&gt;/stop&lt;/code&gt;, &lt;code&gt;/interrupt&lt;/code&gt;, &lt;code&gt;/resume&lt;/code&gt; and &lt;code&gt;/fork&lt;/code&gt;, and &lt;code&gt;GET /api/chats/:id/stream&lt;/code&gt; to follow it. When the agent asks for permission, a question or a plan approval, you answer from the UI (or &lt;code&gt;POST /api/chats/:id/permissions/:requestId&lt;/code&gt;).&lt;/p&gt;

&lt;p&gt;The interactive reference is served at &lt;code&gt;/docs&lt;/code&gt; and the OpenAPI 3.1 document at &lt;code&gt;/openapi.json&lt;/code&gt;. If you turned authentication on, send &lt;code&gt;Authorization: Bearer &amp;lt;token&amp;gt;&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;The UI does not poll. One server-sent events feed, &lt;code&gt;GET /api/events&lt;/code&gt;, carries chats, prompts waiting for you, tasks, orchestrations and account rotation, and it resumes with &lt;code&gt;Last-Event-ID&lt;/code&gt; after a drop.&lt;/p&gt;

&lt;h2&gt;
  
  
  Orchestrations
&lt;/h2&gt;

&lt;p&gt;An orchestration is a graph of tasks. Workers run in parallel, each in its own git worktree, and their branches are merged into one integration branch. After that, a verification phase runs your checks (build, tests) on the integration branch under a timeout, and a pull request can be offered. It exists as the &lt;code&gt;POST /api/orchestrations&lt;/code&gt; route and as a screen where you follow the run as steps.&lt;/p&gt;

&lt;p&gt;Two things to watch for: the checks need &lt;code&gt;worktree: true&lt;/code&gt; on the graph engine, and workers do not survive a restart. A task caught by one is marked &lt;code&gt;interrupted&lt;/code&gt; and its chat continues in a new execution while it has attempts left.&lt;/p&gt;

&lt;h2&gt;
  
  
  Several accounts, rotated
&lt;/h2&gt;

&lt;p&gt;Each Claude account gets its own &lt;code&gt;CLAUDE_CONFIG_DIR&lt;/code&gt; and is signed in once. Claudio reads usage per window, moves new work to an account with quota before a limit is hit, replays a turn that hits its limit on the next account, and waits for the reset only when none has any quota left. There is also a small CLI, &lt;code&gt;claudio-accounts&lt;/code&gt;, in &lt;code&gt;packages/accounts&lt;/code&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Reviewing changes inside Claudio
&lt;/h2&gt;

&lt;p&gt;For a chat, a task or the integration branch there is a diff screen built from git and the transcript. Each edit carries the sentence Claude wrote just before it, so you read the change together with its reason.&lt;/p&gt;

&lt;h2&gt;
  
  
  Projects, a board and a team
&lt;/h2&gt;

&lt;p&gt;You can import a directory as a project. It gets a Tasks board with work items (&lt;code&gt;AGN-12&lt;/code&gt;-style keys, five fixed columns, epics, milestones), and a team where each member is a Claude Code agent file with a role. With the flow switched on, a card entering a column starts that role's run. Only you move a card to Done.&lt;/p&gt;

&lt;h2&gt;
  
  
  Guards
&lt;/h2&gt;

&lt;p&gt;Claudio can add &lt;code&gt;PreToolUse&lt;/code&gt; hooks that hold even in &lt;code&gt;bypassPermissions&lt;/code&gt;: no push, no &lt;code&gt;--no-verify&lt;/code&gt;, no recursive delete outside the worktree, no secret written. They are on for orchestration workers and the flow, and configurable per project for chats. The mechanism is a settings file with only Claudio's hooks, passed with &lt;code&gt;--settings&lt;/code&gt;. See &lt;a href="https://github.com/yeyo11/claudio/blob/main/docs/guards.md" rel="noopener noreferrer"&gt;docs/guards.md&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Install
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Docker&lt;/strong&gt; (amd64):&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;docker run &lt;span class="nt"&gt;-d&lt;/span&gt; &lt;span class="nt"&gt;--init&lt;/span&gt; &lt;span class="nt"&gt;--name&lt;/span&gt; claudio &lt;span class="nt"&gt;--restart&lt;/span&gt; unless-stopped &lt;span class="nt"&gt;-p&lt;/span&gt; 127.0.0.1:8797:8797 &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;-v&lt;/span&gt; claudio-config:/home/node/.claude &lt;span class="nt"&gt;-v&lt;/span&gt; claudio-data:/data &lt;span class="nt"&gt;-v&lt;/span&gt; claudio-workspace:/workspace &lt;span class="se"&gt;\&lt;/span&gt;
  ghcr.io/yeyo11/claudio
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Open &lt;code&gt;http://localhost:8797&lt;/code&gt;, sign in with the owner token the container printed once (&lt;code&gt;docker logs claudio&lt;/code&gt;), then sign in to Claude in the setup assistant. Name all three volumes, or replacing the container to update starts again with empty ones.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Desktop app&lt;/strong&gt; (Linux x86_64, &lt;code&gt;.deb&lt;/code&gt; or AppImage):&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;curl &lt;span class="nt"&gt;-fsSL&lt;/span&gt; https://raw.githubusercontent.com/yeyo11/claudio/main/scripts/install.sh | bash
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;As with any script piped to a shell, read it first. The app runs with your own &lt;code&gt;claude&lt;/code&gt; and &lt;code&gt;~/.claude&lt;/code&gt; login, so nothing is sandboxed and chats start in &lt;code&gt;acceptEdits&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;From source&lt;/strong&gt; (Node 22+, pnpm 10, a logged-in &lt;code&gt;claude&lt;/code&gt; on your &lt;code&gt;PATH&lt;/code&gt;):&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git clone https://github.com/yeyo11/claudio &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="nb"&gt;cd &lt;/span&gt;claudio
pnpm &lt;span class="nb"&gt;install
&lt;/span&gt;pnpm dev          &lt;span class="c"&gt;# API on :8797, UI on :5181&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Then: open Claudio, let the setup assistant check Claude Code, press New chat, pick a directory and write a prompt.&lt;/p&gt;

&lt;h2&gt;
  
  
  Before you expose it
&lt;/h2&gt;

&lt;p&gt;A container creates an owner token on its first start. A source install or the desktop app has authentication off until you turn it on. That is right for a port bound to &lt;code&gt;127.0.0.1&lt;/code&gt; and wrong for anything else: with auth off, anyone who reaches the port can start a chat on your account and read every transcript on the machine. The modes are &lt;code&gt;none&lt;/code&gt;, &lt;code&gt;token&lt;/code&gt; (only the SHA-256 is stored) and &lt;code&gt;oidc&lt;/code&gt; (Claudio validates a JWT; it does not log anyone in). Claudio does not terminate TLS, so put a proxy in front. &lt;a href="https://github.com/yeyo11/claudio/blob/main/docs/securing.md" rel="noopener noreferrer"&gt;docs/securing.md&lt;/a&gt; has the details.&lt;/p&gt;

&lt;p&gt;Claudio is a Claude-only fork of Agentry, an independent project, and is not affiliated with Anthropic.&lt;/p&gt;

&lt;h2&gt;
  
  
  What comes next
&lt;/h2&gt;

&lt;p&gt;The roadmap says nothing is planned right now. What is left was decided against for now, with reasons: native app-store shells, per-user push, offline use, a browser login flow for OIDC. If one of those matters to you, open an issue and tell me why.&lt;/p&gt;

&lt;p&gt;The code is MIT-licensed at &lt;a href="https://github.com/yeyo11/claudio" rel="noopener noreferrer"&gt;github.com/yeyo11/claudio&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>claude</category>
      <category>opensource</category>
      <category>selfhosted</category>
      <category>ai</category>
    </item>
  </channel>
</rss>
