Independent AI intelligence Two editions daily · ET
Fervor AI

Analysis · November 18, 2026 · repo

SoduWorkmulti-agentagent-harnessprivacyagent-infrastructure

SoduWork Turns AI Agents Into a Team That Needs Your Sign-Off

The open-source workspace makes one agent check another against criteria you wrote first. Here is how to try it, and the one setting to change before you call it self-hosted.

AI agents finish fast and get trusted slowly. Every developer who uses them knows the feeling: the code arrives in two minutes, and then you spend twenty working out whether it does what you asked. The time the agent saved goes straight back into checking its work.

Most tools treat that checking as your problem. The agent replies, the chat ends, and "done" means the model stopped typing.

SoduWork, an open-source team workspace that hit #5 on Trendshift's daily GitHub board on November 18, starts from the opposite end. Its README puts the idea in one line: "A chat ends with an answer. A SoduWork request ends when the person who asked signs off."

That sounds like a slogan. It's actually a design decision, and it's the part worth stealing even if you never install the thing. You write what "done" means before the work starts. One agent does the work. A different agent, on a different model, checks it against what you wrote. Then a person makes the call.

What SoduWork is, in plain terms

SoduWork is a desktop app plus a small server, which it calls the Hub. The Hub holds requests, plugins, history and approvals. The desktop client is where you chat and approve. Agents do the actual work on your machine or on a cloud runner (a remote machine that runs agents for you).

It doesn't ship its own coding agent. It runs other people's. The README lists Pi, OpenCode, Qwen Code, Kimi Code and Codex among the agent runtimes it can drive, through one adapter layer, and says you can switch runtimes mid-conversation without losing history or the working folder. Pi comes built in. Programs that speak the Agent Client Protocol (ACP), an open standard for connecting editors and agents, can be added with a catalog entry.

The license is MIT, copyright MDiRi, with one carve-out: the SoduWork name and logo are trademarks and aren't covered. Bundled third-party code and tools keep their own licenses. It's young and moving fast. Version 1.13.18 landed on November 18, and the project calls the whole thing a public beta and asks you to evaluate it before production use. Shields.io put it at about 2,800 stars on the same day.

The idea: write "done" before anyone starts

Every SoduWork request carries acceptance criteria, a short list of conditions the result has to meet. You can write them yourself, or let AI draft them from your description and edit what it gets wrong.

The flow in the README runs like this:

  1. Raise a request.
  2. AI refines it and adds acceptance criteria.
  3. Assign it to yourself, a colleague, or an agent.
  4. The agent runs it, often with a team plugin.
  5. A separate AI review checks each criterion, and the assignee confirms.
  6. The requester signs off.
  7. If the method worked, save it as a plugin for next time.

Step 5 is the interesting one. The README's own example: "Pick Pi to do the work. OpenCode, on a different model, reviews it against the acceptance criteria. If the review fails, the work goes back with the reasons."

Why a different model? Think of a proofreader who also wrote the essay. They read what they meant to write, not what's on the page. A second model doesn't share the first one's blind spots in the same way, so it's more likely to notice that the function handles the happy path and nothing else.

And step 6 keeps a human on the hook. The README is direct about who moves work along: "Agents don't hand work to other agents on their own." The plugin and the assignee decide where work goes next. That's a deliberate rejection of the fully autonomous swarm model, and for most teams it's the right call.

Plugins: keeping what worked

The second idea is smaller but practical. When you and an agent get a task right, SoduWork lets you save that conversation as a plugin: a versioned package with the method, inputs, acceptance criteria and steps.

Compare that with the usual fate of a good prompt. It lives in one person's chat history until they forget which thread it was in.

SoduWork plugins can stay private, or go through review before they're shared with a team. Access is granted to teams or people and can be revoked. Plugin versions don't change once published, so a run from last month can be traced to the exact method it used. The README's line on this is good: "Installing something doesn't authorize it."

Try it from source

You need Python 3.12 or newer and Node.js 22.19 or newer. The README also lists Git, which you'll want for cloning; the getting-started guide notes that the source ZIP route doesn't need it. You'll also need an API key from a model provider, because SoduWork brings no model of its own, and real calls cost whatever your provider charges.

On macOS or Linux:

git clone https://github.com/mdiri-ai/SoduWork
cd SoduWork
sh start.sh --desktop

On Windows, use .\start.cmd --desktop in PowerShell or start.cmd --desktop in Command Prompt.

What to expect, per the getting-started guide:

  • The first run installs dependencies and builds the admin console. It can take several minutes and prints a status line about every 15 seconds.
  • It asks you to set a password for the admin account, 12 to 128 characters.
  • When it's ready, the terminal prints SoduWork is ready: http://127.0.0.1:18989, and a browser and the desktop client open. The data lives in a private SQLite database on your machine.

Then connect a model:

  1. In the browser admin console, open Capabilities, then Model catalog, and connect your provider with its base URL and key.
  2. On that service card, choose Add model, enter the provider's exact model ID, and mark it as a Chat model. This step trips people up. Saving the key alone doesn't create a model you can pick.
  3. In the desktop client, start a new conversation, choose Pi and the model you added, and send a small task.

One gotcha from the README: Codex uses its own account and sign-in. It won't pick up the API key you just saved.

Once a plain chat works, try the real feature. Create a requirement, describe the goal, inputs and acceptance criteria, open Arrange execution, pick an agent and model, and inspect what comes back before you accept it. Start with something you can check yourself in two minutes, like turning messy meeting notes into a task table with owners and dates. You'll learn more from watching the review catch (or miss) a gap than from any README.

Before you call it self-hosted, change one setting

SoduWork describes itself as self-hosted, and in the important ways it is. When you run your own Hub, the README says requests, plugins and chat history live there, tasks run in the folder you choose, and each run gets a short-lived credential so keys aren't written into agent config files in plain text.

But read the "Where does my data go?" section before you put a team on it.

The installed desktop client defaults to a hosted service at https://service.soduwork.ai. Whatever Hub the client points at receives usage accounting (conversation ID and title, agent, model and provider names, token and cost counters, timestamps) and, for installed clients, update checks at startup and every six hours with your version, platform and CPU type. The README says plainly that there is "currently no separate setting to disable Hub accounting or installed-client update polling."

The project is upfront that this is operational data, and it says the public source contains no separate analytics upload to MDiRi. The getting-started guide also notes that a client launched from source already points at your local Hub, and the README says source-launched clients skip the installer update checks. Still, conversation titles are often the most revealing thing in a log. A title like "Fix auth bypass in billing service" says plenty.

The fix is simple and worth doing on day one: on every installed client, open Connection on the sign-in screen and point it at your own Hub. The README says that choice survives restarts and upgrades. If you use models that run on your own machine, SoduWork's My models panel keeps their endpoints and keys encrypted in the desktop profile and doesn't upload them to the Hub, at the cost of not working with cloud runners or scheduled tasks.

One more boundary to keep straight: self-hosting the Hub doesn't make model traffic local. The README notes that prompts and files you send to a model provider are visible to that provider. Only a model you run yourself keeps them in your environment.

Honest limitations

  • It's a public beta. The project says so, and a version number above 1.13 doesn't change that. The release on November 18 is marked as a candidate build (a release still being tested) in its own feed.
  • The README disagrees with itself in small ways. A collapsed section of supported runtimes is labeled nine, while the headline list names seven, and the README and the setup guide differ on whether you need Git. Small things, but they tell you the docs move slower than the code.
  • Review by a second model isn't verification. It catches more than self-review. It won't catch a criterion you forgot to write, and two models can share a mistake.
  • You bring the models and pay for them. A worker plus a reviewer means at least two model calls per task, and more when work gets sent back.
  • Cloud runner sandboxing is still on the roadmap, listed as in progress. Treat cloud runs with the same caution as any agent with shell access.
  • Usage accounting can't be switched off, only redirected to a Hub you control.

The part worth keeping, even if you skip the tool

You don't need SoduWork to borrow its best idea. Before your next agent task, write three acceptance criteria. Have a second model, not the one that did the work, check the result against them. Then sign off yourself, out loud, in the pull request.

That habit costs five minutes. It moves "done" from "the model stopped typing" to "the person who asked is satisfied," which is where it belonged all along. And if you'd like a tool that enforces it for a whole team, SoduWork is one of the first open-source ones built around that rule. Point it at your own Hub first.

Sources: mdiri-ai/SoduWork README and LICENSE (main branch, reviewed November 18, 2026, release v1.13.18), SoduWork getting-started guide, SoduWork releases, Trendshift daily board, shields.io star count.