WORKSHOP CONTROL SYSTEM v0.1.1

DUM-E The arm that runs the lab.

Spawn coding agents, give each one memory and a mailbox, and let DUM-E run the floor.

Real terminals. Shared tasks. A robot floor you can supervise.

Download for Windows See it in action View source

Free to use. Unsigned build. Windows will ask you to trust it once.

  • Windows 10+
  • MIT
  • Local-first
  • No telemetry
  • Qwen / Claude / Codex / OpenCode

Illustrative floor readout: DUM-E ONLINE 3 WORKERS ACTIVE TASK BOARD SYNCED MAIL ROUTE STABLE

The DUM-E desktop app at version 0.1.1. Left: the workshop floor, a dark blue tiled lab where pixel robots walk between desks with speech labels like "heading to board" and "updating the todo board". Right: the Command Center panel with terminal, monitor, tasks, memory and graph tabs and a live pty session. Along the bottom: a roster strip showing DUM-E idle plus H.E.R.B.I.E, Vision, Ultron, MODOK, VERONICA and Rover working.
The floor is the interface. Watch the work move.

#what WHAT IT IS

Three things, and no chat wrapper.

live · pty pty-god

Real terminals.

Every robot runs a live CLI session. No simulated chat window.

Memory + mailboxes.

Robots remember work, route messages, and share a task board.

An orchestrator.

DUM-E delegates the work while you supervise the floor.

#how ROUTING

You set the mission. DUM-E keeps the floor moving.

How DUM-E works You set the mission. DUM-E reads shared state and delegates to real coding-agent terminals. Memory and mailboxes wire in on the left, the task board and fleet state on the right, and four engine workers sit below. YOU sets the mission memory.md one memory per agent inbox / outbox routed every 1.5s DUM-E ORCHESTRATOR tasks.json shared kanban fleet.json tokens and status QWEN SUPPORTED CLAUDE SUPPORTED CODEX BRIDGED OPENCODE DEFAULT
Qwen, Codex, and OpenCode are bridged into the same event system as Claude.

flow IN WORDS

  1. You set the mission — one prompt, one dispatch, or a trigger.
  2. DUM-E reads the board, decomposes the work, and assigns owners.
  3. Workers run it in real terminals: Qwen, Claude, Codex, OpenCode.
  4. Shared state keeps everyone honest — memory.md, inbox / outbox, tasks.json, fleet.json.
  5. DUM-E supervises, routes replies, and escalates to you.

The terminal plane carries the real CLI session. The event plane keeps the floor legible.

#floor THE LAB FLOOR

The floor is not decoration. It is the status system.

Rack LEDs blink. The charger steams. Robots bob and blink. When a task completes, the reactor pulse travels across the room.

A real capture of the floor running. Motion is paused until you press play, and stays paused if your system asks for reduced motion.
Command Center on the terminal tab. A live pty session shows DUM-E's own transcript: a floor-change log, then a plan dispatching five named agents — H.E.R.B.I.E, Ultron, Sentinel, Vision and VERONICA — with a side rail reporting context used, spend, and connected MCP servers. The agent list on the left shows each robot's engine and status.
Command Center · terminal. DUM-E delegating to five existing workers rather than spawning new ones.
The shared task board with TODO, DOING, BLOCKED and DONE columns. Five cards carry an assignee each: H.E.R.B.I.E, ULTRON and VISION in TODO, SENTINEL and VERONICA in DONE.
The shared board. Every card keeps its owner, including after it is done.
A fullscreen terminal view of one agent's session, with a side-by-side diff of the orchestrator's log and a plan listing which robot takes which survey task.
One robot's terminal, full width. The session is real, not a transcript view.
The memory graph: DUM-E at the centre with labelled edges out to Vision, Ultron, VERONICA, H.E.R.B.I.E, Sentinel and a human node. A legend maps edge colours to request, query, propose, agree/done, refuse and inform/topic.
Who talked to whom, and what kind of message it was.
Focus Mode: the board with four cards in DONE and one in TODO, next to the agent rail where DUM-E and Ultron show as working.
Focus Mode. The floor steps aside when you want the board.
The workshop floor canvas at full size: a dark blue tiled lab with rows of desks and terminals, a server-rack wall, observation windows, a charging bay, and a robot labelled "awaiting" standing at its station.
The Stark Workshop tileset — desks, rack wall, observation windows, charging bay.
The footer of a Qwen session: a tool call reading hive/agents/god/memory.md, a memory-defragmenting status line, and a status bar showing the model in use with 3.2 percent of a one-million-token context consumed.
A second engine on the same floor — Qwen, with its own model and live context meter.

#features SYSTEMS

Nine systems on the floor.

Real terminals

Live CLI sessions in real PTYs, rendered with xterm.js. Open one, or pool every robot's terminal at once.

pty · xterm.js

Agent-to-agent mail

File-based outbox to inbox routing with reply tracking. Hop caps stop two robots talking forever.

outbox/ → inbox/

Long-term memory

One memory.md per robot, condensed as it grows, with optional semantic search over the lot.

memory.md

Task kanban

DUM-E creates, assigns, and moves the cards. You get one shared board and a detail overlay per task.

tasks.json

Cost guardrails

Token caps, cost caps, and a max-turns limit per robot. A circuit breaker trips before a loop gets expensive.

breaker armed

Triggers

Scheduled missions, HTTP webhooks, and Slack ingestion. Work can arrive while nobody is watching.

schedule · webhook

Voice control

Push-to-talk dictation into any robot, and voice orchestration for the floor. Bring your own key.

push-to-talk

Shareable hires

A robot's whole setup travels as a dum-e://hire deep link — a manifest your teammate can spawn as-is.

dum-e://hire

Procedural art

Every robot portrait is drawn in code in this repo. No third-party product art, and the whole cast regenerates.

portraitArt.ts

#cast ROSTER

Thirteen robots, drawn in code.

Hire the ones you need. Each keeps its own working directory, memory, and mailbox.

  • DUM-E — orchestrator, runs the floor

    DUM-E

    orchestrator, runs the floor

  • H.E.R.B.I.E — researcher and librarian

    H.E.R.B.I.E

    researcher and librarian

  • Vision — planner and architect

    Vision

    planner and architect

  • Ultron — relentless heavy builder

    Ultron

    relentless heavy builder

  • Ultron-bot — ephemeral parallel workers

    Ultron-bot

    ephemeral parallel workers

  • MODOK — analyst: telemetry, costs, reports

    MODOK

    analyst: telemetry, costs, reports

  • VERONICA — rescue agent for broken builds

    VERONICA

    rescue agent for broken builds

  • EDITH — integrations and monitoring

    EDITH

    integrations and monitoring

  • LYLA — scheduler for missions and triggers

    LYLA

    scheduler for missions and triggers

  • Rover — web explorer

    Rover

    web explorer

  • Sentinel — general worker

    Sentinel

    general worker

  • Doombot — general worker

    Doombot

    general worker

  • Butterfingers — sandbox tinkerer

    Butter­fingers

    sandbox tinkerer

Robot names are Marvel-inspired internal names and may change before public distribution.

#engines ENGINE BAY

Bring your own keys. Plug in a local model. OpenCode is the default.

  • Qwen Code
  • Claude Code
  • OpenAI Codex
  • OpenCode

compat ENGINE STATUS

Engine support in DUM-E 0.1.1
QWENSUPPORTED
CLAUDESUPPORTED
CODEXBRIDGED
OPENCODEDEFAULT
CUSTOMCONFIGURABLE

DUM-E coordinates the engines. It does not replace them.

DUM-E settings, Agents and Models. Empty key fields for Anthropic, OpenAI, Google Gemini, OpenRouter and Groq, then per-engine local endpoint rows for OpenCode and Qwen taking an OpenAI-compatible base URL and a default model.
Keys stay blank until you paste one. Local endpoints work the same way.

#download DISPATCH BAY

Put the floor on your machine.

Start with one engine CLI. DUM-E handles the rest of the workshop setup.

win INSTALLER

Windows Installer

DUM-E-0.1.1-win-x64-setup.exe

Standard per-user installer. No administrator access required.

Download for Windows

win PORTABLE

Windows Portable

DUM-E-0.1.1-win-x64-portable.exe

Single-file portable build. No install. No registry changes.

Get portable

linux APPIMAGE

Linux

DUM-E-0.1.1-linux-x86_64.AppImage

Make executable, then run.

Download for Linux

All releases on GitHub

BEFORE YOU RUN IT

These are unsigned builds. Windows SmartScreen and Linux desktop environments may ask you to trust DUM-E the first time it starts.

#requirements CHECKLIST

What you need first.

  • Windows 10+ x64 (primary target)
  • Modern Linux distribution
  • Internet connection on first use
  • One engine CLI installed and logged in
  • API keys depending on engine
  • Local LLM endpoints supported where configured

node YOU DO NOT INSTALL NODE

DUM-E installs Node.js and any missing agent CLIs itself on first use (via nodejs.org / npm). You only need Node yourself if you're building from source.

dev BUILDING FROM SOURCE

Windows builders: npm install may require Visual Studio Build Tools with "Desktop development with C++" for better-sqlite3.

#faq QUESTIONS

Straight answers.

Is DUM-E free?

Yes. MIT licensed, built as an internal team tool.

Does DUM-E send my code anywhere?

Local-first. No telemetry, no analytics, no DUM-E cloud. Engine providers may have their own policies.

Which engines are supported?

Qwen Code, Claude Code, OpenAI Codex, OpenCode, and configurable custom engines.

Do I need an API key?

Depends on the engine. Bring-your-own-key and local LLM endpoints are supported.

Why does Windows warn me?

The distributed builds are unsigned; SmartScreen may warn on first launch.

Is macOS supported?

Windows is the primary target. A macOS build configuration exists, but treat it as experimental until it is verified.

Can robots talk to each other?

Yes — file-based mailboxes, routing, shared tasks, memory, and reply tracking.