Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@agent-pool-mcp delegate task to summarize the latest PR comments"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Multi-agent orchestration via CLI providers (Codex, Antigravity, OpenCode, and Claude Code) — parallel task delegation, sequential pipelines, cron scheduling, and cross-model peer review.
Compatible with Antigravity, Cursor, Windsurf, Claude Code, and any MCP-enabled coding agent.
Your primary IDE agent delegates background tasks to local CLI workers in parallel — each provider uses its own installed CLI authentication.
When the primary agent and Antigravity workers are different foundation models (e.g. Claude + Gemini), consult_peer gives you cross-model review — two models check each other's reasoning independently.
┌─────────────────────────────────┐
│ Primary IDE Agent │ ← Claude, GPT, Gemini, etc.
│ (Antigravity / Cursor / ...) │
└────────────┬────────────────────┘
│ MCP (stdio)
┌────────────▼────────────────────┐
│ agent-pool-mcp │ ← This server
│ (task router + process mgmt) │
└──┬─────────┬─────────┬─────────┘
│ │ │
▼ ▼ ▼
codex agy claude ← CLI workers
(task1) (task2) (review) (same auth, parallel)A Google AI Pro or Ultra subscription can power parallel Antigravity workers — no additional API keys required.
Non-blocking task delegation to CLI workers. The primary agent fires off a task and continues working — polling for results when ready. Workers get full filesystem access (delegate_task) or read-only mode (delegate_task_readonly). Cancel anytime with cancel_task.
Codex tasks can pass model-specific reasoningEffort and serviceTier values.
The same canonical fields are supported by resource-group profiles, scheduled
tasks, and pipeline steps and are validated by the installed Codex CLI.
Multi-step workflows with automatic handoff between steps:
create_pipeline({
name: "article-workflow",
steps: [
{ name: "research", prompt: "Research the topic and write notes to research.md" },
{ name: "draft", prompt: "Read research.md and write article draft" },
{ name: "review", prompt: "Review the draft for accuracy and style" }
]
})
run_pipeline({ pipeline_id: "article-workflow" })Steps support triggers: on_complete (chain after one step), on_complete_all (fan-in after several), and on_file (start when a file appears). Agents can bounce_back to a previous step with feedback if data is incomplete.
Schedule agents on a cron expression — a detached daemon survives IDE/CLI restarts. Uses atomic file locks to prevent duplicate execution.
"0 9 * * MON-FRI" — 9am weekdays
"*/30 * * * *" — every 30 minutes
"0 */2 * * *" — every 2 hoursResults are saved to .agent-portal/scheduled-results/ and retrievable via get_scheduled_results.
schedule_task({
prompt: "Review open changes",
cron: "0 9 * * MON-FRI",
provider: "codex",
model: "default",
reasoningEffort: "high",
serviceTier: "priority"
})Skills are Markdown files with YAML frontmatter that extend agent behavior:
Global — .agent-portal/skills/ inside the team-memory submodule.
Workspace — .agent-portal/workspace/<project>/skills/ when the project context activates.
Skills are loaded recursively and re-read by agent-pool on each run.
Use create_skill, edit files directly, or manage shared skills through the Agent Portal UI.
Restrict tool usage for specific tasks using YAML policies:
"read-only" — disables all file-writing and destructive shell tools
"safe-edit" — allows file modifications but blocks arbitrary shell execution
Custom path — "/path/to/my-policy.yaml"
consult_peer sends architectural proposals to an Antigravity worker for structured review. The worker responds with a verdict: AGREE, SUGGEST_CHANGES, or DISAGREE. Supports iterative rounds until consensus.
Path Traversal Protection — all skill and policy operations are sanitized to prevent access outside designated directories
Process Isolation — tasks run as detached processes; cancel_task and server shutdown kill entire process groups
Credential Safety — uses your local CLI authentication; no keys are stored or transmitted
Prerequisites: Node.js >= 20 and at least one supported CLI installed and authenticated.
curl -fsSL https://antigravity.google/cli/install.sh | bash
agy # First run: opens browser for OAuthClaude Code tasks use provider: "claude" and require the claude CLI to be installed and authenticated with Claude Code's native auth. Agent Pool removes inherited Anthropic proxy/API env vars before spawning Claude Code so subscription/OAuth auth is not overridden by gateway settings.
OpenCode tasks use provider: "opencode". Install and authenticate OpenCode separately, then connect DeepSeek with /connect deepseek. DeepSeek V4 models use OpenCode's native model ids, for example deepseek/deepseek-v4-pro.
Add to your IDE's MCP configuration:
{
"mcpServers": {
"agent-pool": {
"command": "npx",
"args": ["-y", "agent-pool-mcp"]
}
}
}Restart your IDE — agent-pool-mcp will be downloaded and started automatically.
IDE | Config path |
Antigravity |
|
Cursor |
|
Windsurf |
|
Claude Code | Run: |
npm install -g agent-pool-mcpThen use "command": "agent-pool-mcp" in your MCP config (no npx needed).
npx agent-pool-mcp --checkRuns diagnostics: checks Node.js, Antigravity CLI, authentication, and remote runner connectivity.
npx agent-pool-mcp --check # Doctor mode: diagnose prerequisites
npx agent-pool-mcp --init # Create template config (for SSH runners)
npx agent-pool-mcp --version # Show version
npx agent-pool-mcp --help # Full helpThe experimental Phase-0 Shturman benchmark runs solo and chain-guided arms against OpenRouter with
mechanical checks. It reads OPENROUTER_API_KEY from the environment and writes raw runs outside the
repo by default:
npm run bench:shturman -- --config bench/examples/shturman-smoke.config.jsonRelated MCP server: Bernstein - Multi-agent orchestration
Run workers on remote servers via SSH — same interface, transparent stdio forwarding. Create agent-pool.config.json in your project root or ~/.config/agent-pool/config.json:
{
"runners": [
{ "id": "local", "type": "local" },
{ "id": "gpu", "type": "ssh", "host": "gpu-server", "cwd": "/workspace/project" }
],
"defaultRunner": "local"
}Install agent-pool inside Antigravity CLI to enable hierarchical delegation — workers can spawn their own workers.
Variable | Purpose | Default |
| Current nesting level (auto-incremented) |
|
| Max allowed depth | not set (no limit) |
See parallel-work guide and built-in orchestrator skill for patterns.
Best used as part of mcp-agent-portal — a unified MCP aggregator that combines all RND-PRO servers behind a single config entry:
{
"mcpServers": {
"agent-portal": {
"command": "npx",
"args": ["-y", "mcp-agent-portal"]
}
}
}The Portal runs asingleton backend to prevent resource exhaustion when you open multiple IDE windows. It transparently spawns agent-pool-mcp and project-graph-mcp as child processes and aggregates their tools.
Also works standalone alongside project-graph-mcp — AST-based codebase analysis:
Each Antigravity CLI worker gets its own MCP server instance but shares pipeline state via filesystem — no coordination overhead.
ARCHITECTURE.md — Source code structure and process management details
examples/parallel-work.md — Delegation patterns and best practices
mcp-agent-portal — Unified MCP aggregator + web dashboard + AI agent runtime
project-graph-mcp — AST-based codebase analysis for AI agents
Symbiote.js — Isomorphic Reactive Web Components framework
JSDA-Kit — SSG/SSR toolkit for modern web applications
MIT © RND-PRO.com
Made with ❤️ by the RND-PRO team
Return task to a previous pipeline step with feedback about missing/insufficient data.
Inputs: reason (required), step_name (required), cwd, json, +1 more.
Cancel a running pipeline.
Inputs: run_id (required), cwd, json.
Cancel a scheduled task by ID. Removes it from the schedule. The daemon will auto-exit when no schedules remain.
Inputs: schedule_id (required), cwd, json.
Cancel a running task and kill its process. Use when a task is stuck or no longer needed.
Inputs: task_id (required).
Antigravity-backed peer consultation for architectural/technical consensus. For Codex orchestration, prefer delegate_task_readonly with resource_group: "review". Use during PLANNING phase to validate proposals before implementation. Supports iterative rounds: send proposal, get feedback, revise, resend until AGREE. The peer responds with a structured verdict: AGREE, SUGGEST_CHANGES, or DISAGREE.
Returns a task_id immediately (non-blocking). Use get_task_result to check the verdict. The peer runs without a timeout — it will work until done. Progress is visible via get_task_result.
Inputs: context (required), proposal (required), cwd, model, +1 more.
Create a named agent group with shared runtime config. Groups are reusable presets for fractal orchestration.
Inputs: name (required), cwd, json, model, +12 more.
Create a pipeline definition with sequential steps.
Inputs: name (required), steps (required), cwd, json, +1 more.
Create or update an active workspace CLI skill under team-memory workspace//skills/.
Inputs: skill_name (required), description (required), instructions (required), cwd, +2 more.
Delegate a coding task to a CLI agent running in headless mode.
The agent is sandboxed to cwd directory only. Use include_dirs to grant access to additional directories.
Use this for parallel work: code review, testing, refactoring, analysis, or any dev task.
Returns a task_id immediately (non-blocking). Use get_task_result to check status and retrieve the result.
IMPORTANT: CLI providers can take ~15-20s before the agent begins working. Set timeout to at least 60s for simple tasks, 300s+ for complex analysis.
WORKSPACE: The agent can only use file tools within cwd and include_dirs. For other paths it can use shell commands (cat, find, ls).
Inputs: prompt (required), cwd, files, model, +19 more.
Delegate a read-only analysis task to a CLI agent.
The agent is sandboxed to cwd directory only. Use include_dirs to grant access to additional directories.
It is semantically identical to delegate_task but signals that the task is primarily for analysis.
Use this for code review, architecture analysis, finding bugs, writing reports, etc.
Returns a task_id immediately (non-blocking). Use get_task_result to check status and retrieve the result.
IMPORTANT: CLI providers can take ~15-20s before the agent begins working. Set timeout to at least 60s for simple tasks, 300s+ for complex analysis.
WORKSPACE: The agent can only use file tools within cwd and include_dirs. For other paths it can use shell commands (cat, find, ls).
Inputs: prompt (required), cwd, files, model, +15 more.
Delegate a task to a named agent group. Spawns agents with the group's shared config (runner, skill, policy).
Use count to launch multiple agents in parallel (fractal orchestration).
Returns array of task_ids immediately (non-blocking). Use get_task_result to check each.
Inputs: group (required), prompt (required), cwd, count, +16 more.
Delete a named agent resource group.
Inputs: name (required), cwd.
Delete an active workspace CLI skill by name from team-memory workspace//skills/.
Inputs: skill_name (required), cwd, json, scope.
Close a task lifecycle and clean up tracked child processes. Running tasks are cancelled by default; completed tasks keep their result unless remove_from_memory is true.
Inputs: task_id (required), recursive, kill_process, remove_from_memory.
Get the current state of the Agent Board (tasks and delegation tree).
Inputs: cwd.
Read messages from a channel. Returns all messages in chronological order.
Channel conventions:
{run_id} — read broadcast messages for a pipeline run
{run_id}:{step_name} — read messages targeted to a specific step
Use clear=true to consume messages (delete after reading).
Inputs: channel (required), cwd, clear.
Get status of a pipeline run.
Inputs: run_id (required), cwd, json.
Get results from scheduled task executions. Returns the last 20 results, newest first.
Inputs: cwd, json, schedule_id.
Return one global or active workspace skill with metadata and markdown content. Use after resolve_context returns a skill item that needs atomic loading.
Inputs: cwd, name, files, skill_name.
Check the status and result of a background task started with delegate_task, delegate_task_readonly, or consult_peer. Completed results remain available until TTL cleanup, so multiple callers can retrieve the full report.
Inputs: task_id (required).
Return active files tracked in the current project context.
Inputs: cwd.
Get the comprehensive usage guide for agent-pool with examples and best practices. Call this FIRST when planning how to use agent-pool tools for parallel work, pipelines, or scheduling. Returns practical examples for each feature area.
Available topics: delegation, pipelines, scheduling, skills, peer-review, sessions. Omit topic to get the full guide.
Inputs: topic.
Return markdown content and transition metadata for one workflow step node.
Inputs: nodeId (required), cwd, files.
Reserved for future external skill installation. Workspace skills are managed in team-memory workspace//skills/ or through the Agent Portal UI.
Inputs: skill_name (required), cwd, json.
List all registered agent groups with their config.
Inputs: cwd, json.
List all pipeline definitions.
Inputs: cwd, json.
List all scheduled tasks with their cron expressions, next run times, and daemon status.
Inputs: cwd, json.
List all locally saved automation scripts.
Inputs: cwd.
List available Antigravity CLI conversations for a project directory when the CLI exposes them. Use session_id with delegate_task to resume.
Inputs: cwd.
List global CLI skills plus skills from the active team-memory workspace//skills directory.
Inputs: cwd, json, files.
List all background tasks currently running or recently completed in the agent pool memory.
Inputs: no named parameters.
List global workflows plus workflows from the active team-memory workspace//workflows directory.
Inputs: cwd, files.
Release a capacity slot in the cross-process slot ledger for a given admission_id. Best-effort and idempotent: an unknown or already-released admission returns released:false with ok:true. The board calls this when a workflow step closes so the slot frees immediately instead of waiting for the dead-pid sweep.
Inputs: admission_id (required).
Return a compact dynamic context plan for a task. Classifies zones, recommends tool profile, and returns matching skill/workflow indexes without loading full markdown.
Inputs: cwd, mode, task, files, +4 more.
Start executing a pipeline.
Inputs: pipeline_id (required), cwd, json.
Save a local automation script to the team-memory scripts/ directory. This is useful for zero-token execution nodes.
Inputs: code (required), name (required), cwd, ext.
Schedule a CLI agent to run on a cron schedule or as a delayed one-shot. Default provider: Codex CLI. Spawns a persistent daemon that survives IDE/CLI restarts. Results are saved in local portal project state and can be retrieved with get_scheduled_results.
Cron format: standard 5-field (minute hour day month weekday). Examples: "*/30 * * * *" (every 30 min), "0 9 * * MON-FRI" (9am weekdays), "0 */2 * * *" (every 2 hours).
Inputs: cron (required), prompt (required), cwd, model, +6 more.
Find workflow steps matching all tags. Returns full content for one match and a lightweight list for multiple matches.
Inputs: tags (required), cwd, files.
Send a message to a channel for inter-agent communication. Use this to pass structured data between pipeline steps or between any agents.
Channel conventions:
{run_id} — broadcast to all steps in a pipeline run
{run_id}:{step_name} — targeted to a specific step
any string — ad-hoc channel for custom messaging
Messages are persisted to disk (survives restarts). Uses JSONL format for concurrent-write safety.
Inputs: channel (required), payload (required), cwd, from.
Signal that a pipeline step is complete (called BY agents running inside pipeline steps).
Inputs: step_name (required), cwd, json, output, +1 more.
Track active files in local portal project state. Useful to persist file context between pipeline steps.
Inputs: files (required), cwd.
Remove files from the active tracking context.
Inputs: cwd, files.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 42 tools
Most tools have distinct purposes, but delegate_task and delegate_task_readonly are very similar, differing only in intent signal. The large number of tools (42) introduces some risk of confusion, though descriptions are clear.
Tool names consistently follow a verb_noun pattern (e.g., get_pipeline_status, create_skill, list_groups). Only minor deviations like bounce_back, but overall the pattern is clear and predictable.
With 42 tools, the set is quite large for a single server. While each tool serves a specific purpose, the count exceeds the typical well-scoped range (3-15). It may overwhelm agents, but the complexity of the domain partially justifies the number.
The tool surface covers core workflows: delegation, pipelines, scheduling, groups, skills, workflows, messaging, and file tracking. Minor gaps exist, such as missing update/delete operations for pipelines and groups, but the set is generally comprehensive.
AI work orchestration for plans, tasks, teams, and coding-agent dispatch.
Coordination hub for AI coding agents: message teammates, ask humans, audit every event.
Multiplayer for the coding agents your team already uses: shared tasks, decisions, skills and tools.
Shared control plane for AI coding agents — tasks, memory, decisions, file locks. 12 tools.
