MCP Goose Subagents Server
Mentioned as the technology for building REST APIs in example subagent instructions, allowing for the creation of backend services with authentication.
Enables backend development capabilities for creating Node.js services and APIs through specialized subagents.
Supports frontend development through specialized subagents that can create React components and integrate them with backend APIs.
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., "@MCP Goose Subagents Server create a recipe for a backend developer specializing in Node.js APIs"
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.
MCP Goose Subagents Server
An MCP (Model Context Protocol) server that enables AI clients to delegate tasks to autonomous developer teams using Goose CLI subagents.
Features
Delegate to Subagents: Create specialized AI agents for different development roles
Parallel & Sequential Execution: Run agents simultaneously or in sequence
Recipe System: Create reusable agent configurations
Session Management: Track and retrieve results from active subagent sessions
Pure Goose CLI Integration: Uses only Goose CLI for subagent delegation
Related MCP server: Claude Team MCP
Prerequisites
Goose CLI installed and configured
Node.js (v18 through v24; the tested package compatibility bound is
>=18 <25)Alpha features enabled for Goose subagents
Installation
npm installUsage
1. Add to MCP Configuration
Add this server to your MCP client configuration (e.g., mcp_config.json):
{
"mcpServers": {
"goose-subagents": {
"command": "node",
"args": ["path/to/mcp-goose-subagents/src/index.js"],
"env": {
"ALPHA_FEATURES": "true"
}
}
}
}2. Enable Goose Alpha Features
export ALPHA_FEATURES=trueAvailable Tools
delegate_to_subagents
Delegate development tasks to specialized Goose subagents.
Parameters:
task(string): The development task to delegateagents(array): Array of subagent configurationsrole(string): Agent role (e.g., "backend_developer", "frontend_developer")instructions(string): Specific instructions for the agentrecipe(string, optional): Recipe name to use
execution_mode(string): "parallel" or "sequential"working_directory(string, optional): Working directory for agents
working_directory must already exist beneath GOOSE_MCP_ROOT (the server's startup directory by default). Relative or absolute paths that resolve inside the root are accepted; traversal and symlinks that resolve outside it are rejected.
Example:
{
"task": "Build a REST API with authentication",
"agents": [
{
"role": "backend_developer",
"instructions": "Create Express.js API with JWT authentication"
},
{
"role": "database_engineer",
"instructions": "Design and implement user database schema"
},
{
"role": "security_auditor",
"instructions": "Review authentication implementation for security issues"
}
],
"execution_mode": "parallel"
}create_goose_recipe
Create reusable Goose recipes for specialized subagents.
Parameters:
recipe_name(string): Name of the reciperole(string): Agent roleinstructions(string): Detailed instructionsextensions(array, optional): Goose extensions to enableparameters(object, optional): Recipe parameters
list_active_subagents
List currently active subagent sessions and their status.
get_subagent_results
Retrieve results from completed subagent sessions.
Parameters:
session_id(string): Session ID to get results for
Example Workflows
Autonomous Full-Stack Development
// Delegate a complete web app development task
{
"task": "Create a todo app with React frontend and Node.js backend",
"agents": [
{
"role": "project_architect",
"instructions": "Design overall architecture and create project structure"
},
{
"role": "backend_developer",
"instructions": "Build REST API with CRUD operations for todos"
},
{
"role": "frontend_developer",
"instructions": "Create React components and integrate with API"
},
{
"role": "qa_engineer",
"instructions": "Write tests and ensure quality standards"
}
],
"execution_mode": "sequential"
}Parallel Code Review
{
"task": "Review authentication module for security and performance",
"agents": [
{
"role": "security_auditor",
"instructions": "Analyze for security vulnerabilities and best practices"
},
{
"role": "performance_reviewer",
"instructions": "Identify performance bottlenecks and optimization opportunities"
},
{
"role": "code_quality_reviewer",
"instructions": "Check code style, maintainability, and documentation"
}
],
"execution_mode": "parallel"
}Agent Roles Examples
backend_developer- API development, server-side logicfrontend_developer- UI/UX implementation, client-side codedatabase_engineer- Schema design, query optimizationdevops_engineer- Deployment, CI/CD, infrastructureqa_engineer- Testing, quality assurancesecurity_auditor- Security review, vulnerability assessmentcode_reviewer- Code quality, best practicesdocumentation_writer- Technical documentation, API docsproject_architect- System design, architecture planning
Environment Variables
ALPHA_FEATURES=true- Required for Goose subagentsGOOSE_RECIPE_PATH- Path to custom recipe directoryGOOSE_MCP_ROOT- Trusted workspace root. Defaults to the server startup directory.GOOSE_MCP_TIMEOUT_MS- Goose process timeout in milliseconds (default 15 minutes, capped at 1 hour).
Security boundary
Tool arguments are model-controlled. This server constrains Goose's working directory and generated recipe paths to GOOSE_MCP_ROOT, invokes Goose without a shell, limits captured output, times out child processes, and terminates their process group during timeout or shutdown. Dependency versions are pinned in package.json and package-lock.json.
These are application-level guardrails, not a sandbox. Goose inherits the server's environment and operating-system permissions and may access resources outside the workspace through its own tools or subprocesses. Run the server under a dedicated, least-privileged OS account or container, expose only necessary credentials, and set GOOSE_MCP_ROOT explicitly for untrusted requests.
Troubleshooting
Subagents not working: Ensure
ALPHA_FEATURES=trueis setGoose not found: Verify Goose CLI is installed and in PATH
Recipe not found: Check
GOOSE_RECIPE_PATHor place recipes in working directory
License
MIT
Available Tools
4 toolscreate_goose_recipeC
Create a reusable Goose recipe for specialized subagents
Inputs: recipe_name (required), role (required), instructions (required), extensions, +1 more.
delegate_to_subagentsC
Delegate tasks to Goose CLI subagents for autonomous development
Inputs: task (required), agents (required), execution_mode, working_directory.
get_subagent_resultsC
Get results from completed subagents
Inputs: session_id (required).
list_active_subagentsB
List currently active subagents and their status
Inputs: no named parameters.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 4 tools
Each tool has a clearly distinct purpose with no overlap: create_goose_recipe handles recipe creation, delegate_to_subagents initiates task delegation, get_subagent_results retrieves results, and list_active_subagents monitors subagent status. The descriptions clearly differentiate their functions, making misselection unlikely.
All tool names follow a consistent verb_noun pattern (create_goose_recipe, delegate_to_subagents, get_subagent_results, list_active_subagents) with snake_case throughout. The naming is predictable and readable, with no deviations in style or convention.
With 4 tools, the count is reasonable for managing subagents, covering creation, delegation, result retrieval, and status listing. It is slightly lean but well-scoped for the apparent purpose, though additional tools for updating or deleting recipes might be expected in a more comprehensive set.
The tool set covers core workflows: creating recipes, delegating tasks, getting results, and monitoring status. Minor gaps exist, such as no tools for updating or deleting recipes, and no direct control over subagents (e.g., stopping them), but agents can likely work around these with the provided operations.
Maintenance
Related MCP Connectors
MCP server for AI agents to plan, verify, and deploy Cloudflare-native apps.
MCP server for building and testing AI agents with multi-model experimentation and insights.
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Related MCP Servers
- AlicenseBqualityDmaintenanceAn MCP server that enables AI clients to delegate tasks to autonomous developer teams using Goose CLI subagents, supporting parallel and sequential execution across specialized roles like backend developers, frontend developers, and security auditors.4MIT
- AlicenseNot gradedqualityDmaintenanceA Model Context Protocol (MCP) server that turns multiple AI coding agents into a coordinated team that chats, debates, remembers, audits security, and works in parallel on the same project.MIT
- AlicenseAqualityCmaintenanceAn MCP server that turns independent AI agents into a coordinated engineering team with shared task board, context, review loop, and enforced plan-implement-review-iterate workflow.24MIT
- AlicenseNot gradedqualityDmaintenanceMCP server for coordinating multiple AI agents across developers and vendors with a shared job board, per-file locking, and live project context.7AGPL 3.0