bob-control MCP server
Commit Nov 9, 2026Turns AI coding agents into unattended queue workers by managing tasks through a SQLite-based board with dependency and priority orchestration.
Also known as PounceAI/bob-control
- Stars
- 1
- Tools
- 20
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Nov 9, 2026
- License
- Apache-2.0
What is bob-control MCP?
bob-control turns AI coding agents into unattended queue workers by managing tasks through a SQLite-based board with dependency and priority orchestration. It exposes 20 tools, such as create_task, list_tasks, get_task.
Summary generated from the project's README
About bob-control MCP server
Transforming AI coding agents from interactive chat windows into unattended queue workers is the primary function of bob-control. It manages a SQLite-based task board that orchestrates work through dependency and priority ordering. This allows developers to fill a board with tasks that are automatically dispatched, approved within risk guardrails, and verified via command checks or LLM judges.
Users can connect different agents to the same board, such as IBM Bob and Claude Code, allowing them to share a single queue where each agent performs the work it is best suited for. The system supports various connection methods including a CLI, an MCP server, and an auto-dispatch worker. It integrates with IBM Bob 2.x via headless ACP, Bob 2.0 IDE through an in-process API, and Bob 1.x using a node-ipc pipe. Setup requires Node 22.5+ and can be configured using the BOB_TASKS_DB environment variable to ensure all processes point to the same project board.
What you can do with it
- 1Automate unattended task executionA developer can set up a worker to pull tasks from a queue and execute them without manual intervention.
- 2Coordinate multi-agent workflowsYou can have Claude Code and IBM Bob work from the same task board to divide labor.
- 3Manage complex task dependenciesOrganize a backlog of coding tasks so that specific jobs only start once their prerequisites are finished.
Written from the project's README. Every use case is checked against a quote from it.
bob-control MCP tools 20
Detected from the READMEcreate_tasklist_tasksget_taskget_next_taskclaim_taskupdate_task_statusadd_task_notesubmit_resultset_task_modeset_task_dependenciesrecord_artifactdelete_task
Show all 20 toolsShow fewer tools
revert_taskboard_reportboard_statusrelease_tasksask_questionanswer_task_questionawait_answerawait_task
Configuration
BOB_TASKS_DBBOB_TASKS_PORTABLE
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachablepounceai/bob-control is public and reachablegithub.com/pounceai/bob-control ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-09github.com/pounceai/bob-control ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model20 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubBob Control
Bob Control turns an AI coding agent from a one-prompt-at-a-time chat window into an unattended queue worker. Fill a board and each task gets dispatched, auto-approved inside risk guardrails, answered when the agent asks a question, verified (a command check or an LLM judge), retried on transient failures, and written back — in dependency and priority order, with no one watching. Gating and an acceptance judge keep it honest, and IBM Bob and Claude Code can share one board so each does the work it's best at.
Concretely: an MCP server + CLI + auto-dispatch worker over a SQLite task board.
The worker pulls each task in dependency and priority order and dispatches it to
IBM Bob (IBM's AI coding agent for IBM i), then
watches it run to completion. On Bob Shell 2.x that dispatch is headless over ACP (bob acp as a
child process — below); on Bob 2.0 IDE it's
in-process (the companion extension calls Bob's exported startTask API); on Bob 1.x it's live
over the node-ipc pipe — one build. Bob is the MCP client; this is the server it connects to — and
Claude Code speaks the same MCP, so it can work the same board as foreman (provision / route /
triage) or worker.
One build, both Bobs — auto-detected. Still on 1.x and want the last pipe-only release? Grab v1.1.0 from Releases. Full matrix: CHANGELOG → Compatibility.
Where it fits
This is the runtime execution + orchestration layer: it actually drives a live agent,
keeps it unattended, and verifies the output. That's a different job from planning /
governance CLIs (e.g. MissionForge), which
deterministically decompose and scope work but don't run an agent. The two compose — plan
upstream, then queue the pieces here with depends_on ordering and let the worker drain them.
What this layer owns that a planning CLI doesn't: live agent control (dispatch, auto-approve,
verify), LLM-judged acceptance, a multi-agent shared board, and command/risk gating.
Setup
npm install # not --ignore-scripts: esbuild's postinstall fetches its binary
npm run build # tsc -> dist/, then bundles claude-plugin/server/server.mjs
npm run smoke # optional self-test
Or skip the clone and run the published package — the MCP server (bob-control) and CLI
(bob-tasks) come straight from npm. Point an MCP client at it instead of an absolute dist/ path:
{
"mcpServers": {
"bob-tasks": { "type": "stdio", "command": "npx", "args": ["-y", "@pounceai/bob-control"] }
}
}
Under Claude Code the board resolves automatically (it sets CLAUDE_PROJECT_DIR); any other MCP
client should add "env": { "BOB_TASKS_DB": "…" } pointing at the board the worker drains — a bare
npx server with no board env writes to a throwaway path inside the npx cache that nothing can share.
Windows + nvm-for-windows:
npxcan fail to resolve the bin ('bob-control' is not recognized). Install globally and run it with plainnodeinstead:npm i -g @pounceai/bob-control, then setcommandtonodeandargsto["<npm root -g>/@pounceai/bob-control/dist/server.js"].
The unattended worker and the Claude Code plugin still want the repo (see below).
Needs Node 22.5+ (uses the built-in node:sqlite, so there's no native build step).
Board path resolution: BOB_TASKS_DB (explicit) › BOB_TASKS_PORTABLE=1 (a shared
~/.bob-tasks/tasks.db) › BOB_TASKS_WORKTREE_SHARED=1 (every linked git worktree resolves the
main worktree's data/tasks.db; a no-op for non-worktree dirs) › CLAUDE_PROJECT_DIR/data/tasks.db
(Claude Code sets CLAUDE_PROJECT_DIR in every MCP server it spawns — plugin and a plain
terminal/project .mcp.json — so both resolve the same project board) › repo-local module-relative
data/tasks.db.
The plugin points each project at its own board (see
Boards are per project). On first open the store also writes a
.gitignore beside itself, so the board never lands as untracked state in a consuming repo.
All processes must agree on one board. The plugin MCP, a terminal-configured MCP, the worker, and Bob each resolve
tasks.dbindependently; if they diverge,await_taskpolls a board nothing writes to and never settles. The server logs the resolved board path on startup — confirm every process prints the same one. The worker is launched outside Claude Code (so it has noCLAUDE_PROJECT_DIR); point it with an explicitBOB_TASKS_DBmatching the project board.
Connecting Bob
Bob reads project MCP servers from .bob/mcp.json. Copy the template and point
it at your clone:
cp .bob/mcp.json.example .bob/mcp.json
# edit the four /absolute/path/to/bob-control paths
The template pins BOB_TASKS_DB to the repo's own data/tasks.db (boards are per
project — see below); for one shared queue across every repo, replace that env entry
with "BOB_TASKS_PORTABLE": "1" on both Bob and the plugin.
Bob hot-reloads .bob/mcp.json on save and lists bob-tasks under the MCP
Servers panel's Project tab. To make it available in every workspace, put the
same mcpServers block in the global file instead:
%APPDATA%\IBM Bob\User\globalStorage\ibm.bob-code\settings\mcp_settings.json
Bob 2.0 keeps its settings under
~/.bob/rather than the%APPDATA%\IBM Bobpath above; the simplest version-independent route is the in-app MCP Servers panel (+ Add Server), which writes to whichever location your Bob build uses. ThemcpServersblock is identical either way — this wiring is independent of the dispatch transport.
Bob Companion (Claude Code plugin)
Because the connector is an MCP server and Claude Code is an MCP client, Claude Code can work the same board Bob drains — as the foreman (provision / route / triage) and as a worker (claim and execute tasks itself). It ships as a self-contained Claude Code plugin in claude-plugin/ so you can use it from any repo, not just this one.
The plugin bundles the connector into a single server/server.mjs (esbuild; no native
deps thanks to node:sqlite), so install is all that's required — no checkout needed at
runtime. Build it, add the local marketplace, install:
npm install && npm run build # build also bundles claude-plugin/server/server.mjs
# in Claude Code, from anywhere:
# /plugin marketplace add /absolute/path/to/bob-control
# /plugin install bob-companion@bob-control
| Surface | What it does |
|---|---|
/bob-new <desc> |
Turn a rough ask into one well-formed task (title, criteria, priority, tags, routed mode) |
/bob-board [tag] |
The board grouped by status, in pull order |
/bob-next [tag] |
What Bob pulls next and the mode it routes to (read-only; never claims) |
/bob-route <id|text> |
Predict the dispatch mode for a task or a hypothetical |
/bob-triage [focus] |
Review the board, propose fixes, apply the safe ones on confirm |
/bob-review-diff [range] |
Queue a read-only Bob (review-mode) code review of the diff you just made; findings land on the board |
/bob-work [tag] [--max N] |
Worker: claim pending tasks Claude can do, execute them, submit results |
/bob-statusline |
Install (or --remove) a live one-line board summary in your Claude Code status line |
bob-foreman subagent |
Split a large request into several correctly-routed, ordered tasks |
| Skills (model-invoked) | Ask for IBM Bob by name to dispatch its specialty modes: bob-review (review), bob-plan (plan), bob-refactor (refactor), bob-security (devsecops) |
The dispatch surfaces — bob-review / bob-plan / bob-refactor / bob-security and
/bob-review-diff — block on Bob via await_task and present the result in the same turn, so
a review / plan / fix runs end-to-end hands-off while a worker is draining the board
(npm run worker); with no worker draining they fall back to "queued as #id".
Boards are per project
The plugin's MCP server points at the open project's own board —
${CLAUDE_PROJECT_DIR}/data/tasks.db — so every repo has its own queue. For Bob to share a
project's queue, its .bob/mcp.json must set the same BOB_TASKS_DB for that project;
tools/init-project-board.mjs <dir> scaffolds a correct
per-project .bob/mcp.json (pointing at the shared connector's dist/server.js, with
BOB_TASKS_DB/cwd set, and creates data/). /bob-work claims tasks as claude and
leaves IBM-i/RPG work for Bob, so the two never double-work a task.
Prefer one queue across every repo instead? Set BOB_TASKS_PORTABLE=1 on both the plugin
and Bob to share a fixed ~/.bob-tasks/tasks.db. Either way the server logs the resolved
board path on startup, so you can confirm both tools agree.
From a plain terminal (no plugin)
A plain claude terminal session gets the tools from a project/user .mcp.json but not the
plugin's skills (/bob-work, bob-review, …) that script the dispatch loop — so without
guidance it may fall back to polling the board by hand instead of blocking. Two things make it work
like the plugin:
-
Point it at the project board. In a hand-written
.mcp.json,${CLAUDE_PROJECT_DIR}is only substituted when you give it a default —${CLAUDE_PROJECT_DIR:-.}(bare${CLAUDE_PROJECT_DIR}is a plugin-only direct substitution). The server also readsCLAUDE_PROJECT_DIRfrom its own environment, so even an unsetBOB_TASKS_DBresolves the same project board the plugin uses:// <project>/.mcp.json { "mcpServers": { "bob-tasks": { "type": "stdio", "command": "node", "args": ["/absolute/path/to/bob-control/dist/server.js"], "env": { "BOB_TASKS_DB": "${CLAUDE_PROJECT_DIR:-.}/data/tasks.db" } } } } -
Drive it with
await_task, don't poll. Aftercreate_task, callawait_taskto block until the task settles; if it returnsneeds_input,answer_task_questionthenawait_taskagain. Don't loop onlist_tasks/board_statusto watch a task —await_taskblocks server-side and needs a worker draining the board (npm run workeragainst the sameBOB_TASKS_DB).
Tools
| Tool | Purpose |
|---|---|
create_task |
Add a task (staged:true = created non-pullable, for bulk curation) |
list_tasks |
List tasks, filter by status/tag |
get_task |
One task plus its notes and any open pending_question |
get_next_task |
Highest-priority pending task; optionally claim it (null while disarmed) |
claim_task |
Mark in_progress and assign (only pending, only while armed) |
update_task_status |
Set status (pending / in_progress / blocked / analysis_done / done / cancelled; staged & needs_input are set by their own tools) |
add_task_note |
Append a progress note |
submit_result |
Complete a task: read-only run → analysis_done; implementation reaches done only with evidence |
set_task_mode |
Set or clear a task's mode slug |
set_task_dependencies |
Set/clear the task IDs this one waits on (all must be done/analysis_done); rejects cycles |
record_artifact |
Record a file/commit/test a worker produced (delete-safety + done-evidence) |
delete_task |
Delete a task; warns/refuses if it recorded artifacts unless force, with optional cleanup |
revert_task |
Roll the working tree back to the task's pre-task checkpoint (undo what it changed) |
board_report |
Markdown standup/audit of the board, grouped by status |
board_status |
Dispatch state: armed?, worker-active heuristic, counts by status |
arm_board / disarm_board |
Resume / pause all dispatch (curation gate) |
release_tasks |
Move staged tasks → pending (release after curation) |
ask_question |
Raise a question for a human; parks the task needs_input (never guess) |
answer_task_question |
Answer a worker's question (by question_id); resumes the worker |
await_answer |
The worker's blocking wait for an answer (poll of the shared board) |
await_task |
Block until a task settles (done / analysis_done / blocked / cancelled / needs_input), then return it with its result — dispatch-and-wait |
A typical Bob loop: get_next_task {claim:true} then add_task_note while working,
then submit_result. If it needs a value it can't determine, ask_question → await_answer
rather than guessing.
From the foreman side, a dispatcher that queues work can create_task → await_task to block
until Bob finishes and act on the result in the same turn — no board polling. await_task is a
chunked poll of the shared board (each call stays under the MCP timeout; call again if it returns
{status:'waiting'}), so the settling write Bob's worker makes "hooks" you straight back into your
turn. It resolves on every settled state — including needs_input, where it hands back Bob's open
question so you can answer_task_question and await_task again.
CLI
The CLI shares the same store:
node dist/cli.js create "Modernize INVRPT report" --priority high --tags rpg
node dist/cli.js create "Bulk task" --staged # non-pullable until released
node dist/cli.js list --status pending --tag rpg
node dist/cli.js show 1
node dist/cli.js claim 1 --assignee bob
node dist/cli.js status 1 blocked # set status (rejects staged/needs_input)
node dist/cli.js mode 1 refactor # set/clear the mode slug
node dist/cli.js deps 3 1,2 # task 3 waits on 1 and 2 (empty clears)
node dist/cli.js note 1 "Waiting on test data"
node dist/cli.js result 1 "Done; 3 procedures extracted"
node dist/cli.js next # next pending task + its routed mode
node dist/cli.js delete 1 [--force] [--cleanup] # refuses if it wrote files; cleanup removes created ones
node dist/cli.js revert 1 [--force] # roll the tree back to task 1's checkpoint while one exists (--force if HEAD moved)
node dist/cli.js stats
node dist/cli.js report # markdown standup/audit of the board
node dist/cli.js report --status blocked --out report.md
# curation gate (pause dispatch while you triage, then release)
node dist/cli.js disarm "triaging" # no worker pulls until armed
node dist/cli.js release --tag batch # staged -> pending (all, or by ids/tag)
node dist/cli.js arm # resume dispatch
node dist/cli.js board # armed? + counts by status
# answer a worker's question (see "Asking a human" below)
node dist/cli.js questions # open questions awaiting an answer
node dist/cli.js answer 5 <question_id> pool size is 20
report groups tasks by status in pull order, each with age, idle time, the
latest note, and a ⚠ stalled flag for in_progress work idle over 30 min — handy
for a standup or spotting wedged tasks. It also prints an audit summary tallying
unattended automation activity from task notes: classifier approvals/denials,
answerer answers/escalations, and human actions (with an estimated classifier
cost). Same output is available to agents via the board_report MCP tool.
Modes
Each task carries a mode (or routes to one); on dispatch the connector sends it to Bob along with a matching risk level and auto-approve profile (see src/modes.ts). Eight built-in modes:
| Mode | Risk | What it's for |
|---|---|---|
ask |
safe | Read-only — explain / research / document. No writes or commands. |
plan |
safe | Read-only planning/design — produces a plan, no code changes. |
review |
safe | Read-only code review — returns structured findings (see below). |
code |
standard | Normal edit + build + run. The default. |
refactor |
standard | Behavior-preserving restructuring/cleanup. |
devsecops |
standard | Security-focused remediation — finds and fixes vulnerabilities (write-capable; the LLM judge verifies the fix). |
orchestrator |
standard | Coordinate a multi-step epic with sub-tasks. |
advanced |
elevated | code plus MCP + browser power. |
Leave a task's mode blank and the keyword router picks one from the title, description, and
tags. The router only auto-routes to ask, advanced, orchestrator, or code; the
specialty modes (plan / review / refactor / devsecops) are reached by setting the mode
explicitly, a tag naming the mode, or the plugin's model-invoked skills.
node dist/cli.js create "Explain the IPC envelope" # routes to ask
node dist/cli.js create "Fix bug in db.ts" # routes to code
node dist/cli.js create "Add export" --mode refactor # explicit
node dist/cli.js route 1 # preview the routed mode
Precedence: explicit mode, then a tag naming a mode, then the keyword router,
then code.
Worker
The worker drains the board one task at a time: pull the next eligible task
(highest priority whose dependencies are all done), route it, dispatch to Bob
in the sidebar, wait for the result, write it back, mark it done (verification and
retry below are opt-in).
npm run worker # drain, then idle-poll
node dist/worker.js --once # one task then exit
node dist/worker.js --tag rpg
node dist/worker.js --dry-run
Flags: --once --tag <t> --dry-run --pipe --poll --timeout --assignee
--new-tab --max-risk <safe|standard|elevated> --retry <N> --detect-plan-stop
--no-notify --no-defer --answer-followups --escalate-all --review-plans
--allow-commands <prefix,prefix> --deny-commands <prefix,prefix> --no-command-gate
--allow-all-commands --no-checkpoint --no-idle-watchdog --idle-timeout <ms>
--no-budget --budget-cap <tokens> --max-turns <n> --webhook <url> --webhook-secret <s>
(plus the verify-and-continue flags below).
Needs Bob running with IPC enabled (see below).
Aborted or timed-out tasks are parked as blocked; with --retry <N> the worker first
re-dispatches a transient failure (timeout/abort) up to N times before parking it.
--detect-plan-stop catches a "completion" that wrote no code (Bob just presented a plan)
and continues it instead of marking it done.
The worker is resilient across Bob restarts: if the IPC pipe drops it reconnects on the next
dispatch (instead of wedging), and on startup it re-queues any task a previous run left
in_progress when it died mid-dispatch, so nothing is stranded.
Each mode has a risk level, and the worker only dispatches tasks at or below
--max-risk (default standard); higher-risk ones stay pending for manual
dispatch. On finish the worker pops a tray toast (--no-notify to silence; the
system sound and terminal bell are off by default).
--webhook <url> POSTs the notable transitions — a task finishing, blocking, needing input, or
retrying, and the worker itself stopping or erroring — to a URL as application/json. One payload
serves three consumers: it carries text (a Slack incoming webhook renders it), content (a Discord
webhook renders it), and the structured { event, seq, data, worker, ts } for a generic receiver
(seq monotonic within worker.run, a per-process id, so a restart reads as a new run, not dropped
deliveries; concurrent POSTs can be reordered). Delivery is
best-effort: a POST never blocks or crashes the drain, bursts past an in-flight cap to a slow endpoint
are dropped, and the worker flushes pending POSTs before it exits so the final event still lands. The
URL is validated at startup (http/https only) and only its host is logged, since a Slack/Discord webhook
URL carries its secret in the path. The payload transmits the repo path (cwd), task titles, and Bob's
question text to that URL — point it only at an endpoint you trust; --webhook-secret <s> HMAC-signs the
body (X-Bob-Signature: sha256=…) so a generic receiver can verify authenticity.
Run it standing (hands-off loop). Creating a task doesn't start Bob — a worker has to pull it.
Keep one always draining and the plugin's dispatch skills become end-to-end hands-off: they
create_task, then await_task hooks back with Bob's result in the same turn (no manual dispatch,
no "check back later"). launch-worker.cmd starts one; autostart it at logon so it's always up.
No admin: drop a shortcut to it in your Startup folder (Win+R → shell:startup). With an
elevated terminal you can use a Scheduled Task instead (Task Scheduler needs admin):
schtasks /create /tn "BobWorker" /sc onlogon /tr "\"<repo>\launch-worker.cmd\"" /f # remove: schtasks /delete /tn "BobWorker" /f
Task dependencies
A task can declare depends_on — other task IDs that must all be done before it
becomes eligible. The worker's pull queue skips a task while any dependency is unmet
(surfaced as blocked on dependencies), so you can queue an ordered pipeline and let one
drain run it end to end. Dependencies are validated when set: a missing ID is rejected, and
an edge that would form a cycle is refused (DFS check in src/db.ts).
node dist/cli.js create "Write tests for INVRPT" # -> #5
node dist/cli.js create "Refactor INVRPT" --depends-on 5 # won't dispatch until #5 is done
node dist/cli.js deps 6 5 # set/clear deps on an existing task (empty clears)
Over MCP, pass create_task {depends_on:[…]} or call the set_task_dependencies tool.
bob-control MCP questions
What tools does bob-control MCP provide?
It exposes 20 tools, including create_task, list_tasks, get_task, get_next_task, claim_task.
How does the worker handle task execution?
The worker pulls tasks in dependency and priority order, dispatches them to an agent like IBM Bob, and watches them run to completion with auto-approval and verification.
Can Claude Code and IBM Bob work on the same task board?
Yes, Claude Code and IBM Bob can share a single board, allowing each to perform the work it is best suited for.
How do I ensure all processes use the same task database?
You should ensure all processes agree on one board by pointing them to the same BOB_TASKS_DB path; the server logs the resolved board path on startup for verification.