Workforce MCP
Workforce MCP equips coding agents with specialist contexts (roles like DE, UI, SRE) for production-grade work, enabling them to adopt specific skills, stack defaults, quality bars, and orchestration patterns. You can load specialist contexts with modes (ask, plan, execute) for task planning and execution; list all available roles and their ownership; list and run pod presets that combine multiple specialties; consult a specialist mid-task for quality checks; hand off context between specialties with findings; run multi-specialty discussions (scrum, critique, premortem, etc.) to surface challenges; and delegate work across specialties with a manager-style breakdown. The orchestration flow is discuss → delegate → execute one specialty at a time, then handoff.
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., "@Workforce MCPload DE context and design the orders gold mart"
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.
Workforce MCP
Specialist context for your agent.
One MCP. When you need UI work, load UI context. Pipeline work → DE. Reliability → SRE. Your agent gets full production-grade skills, discovery questions, stack defaults, quality bars, and handoffs for that specialty — without installing separate skill packs per project.
Security
Stdio-only MCP. No install scripts. No network / shell / eval in our published file. Packs are embedded at build time (no runtime fs). The official MCP SDK is a normal dependency so schema tooling stays upstream — see SECURITY.md.
Related MCP server: ContextAtlas
Mental model
You: call MCP prompt "workforce/DE" for the order pipeline
→ agent loads Data Engineer specialist context
→ agent works AS a data engineer on that taskSame for UI, FE, BE, ML, AI, OPS, SRE, MON, SEC, QA, ARCH, MGR, …
Orchestration flow: discuss → delegate → one specialty at a time.
Pods: workforce/WEB (UI+FE+BE), workforce/DP (DE+DS), workforce/AIP (AI+ML+DS+DE) — roster presets, not mega-skills. Specialty AI ≠ pod AIP.
Install (Cursor)
Use npx (works for everyone — no local node_modules required):
{
"mcpServers": {
"workforce": {
"command": "npx",
"args": ["-y", "@saaalil/workforce-mcp"]
}
}
}Do not set command to node with ./node_modules/@saaalil/workforce-mcp/... unless you have already run npm i @saaalil/workforce-mcp in that same workspace. That path is why installs fail with MODULE_NOT_FOUND.
Or run: npx -y @saaalil/workforce-mcp.
Google Antigravity
Now available in Antigravity as well. Edit ~/.gemini/config/mcp_config.json (or workspace .agents/mcp_config.json) — agent panel → MCP Servers → Manage → View raw config:
{
"mcpServers": {
"workforce": {
"command": "npx",
"args": ["-y", "@saaalil/workforce-mcp@1.4.3"]
}
}
}Use 1.4.3+ (1.4.1 crashed under npx with a double-shebang bug). Optional permissions: allow mcp(workforce/*).
Local clone:
{
"mcpServers": {
"workforce": {
"command": "node",
"args": ["/absolute/path/to/Workforce-MCP/dist/index.js"]
}
}
}Short flags
Flag | Full id | Specialist context for… |
UI |
| Product / UI design |
FE |
| Frontend implementation |
BE |
| APIs / services |
ARCH |
| System architecture |
DE |
| Pipelines / lakehouse / dbt |
DS |
| Experiments / model specs |
ML |
| Model lifecycle / serving |
AI |
| RAG / agents / evals |
OPS |
| CI/CD / platform / IaC |
SRE |
| SLOs / incidents / reliability |
MON |
| OTel / dashboards / alerts |
SEC |
| Threat model / authz / supply chain |
QA |
| Test strategy / release gates |
MGR |
| Delegate slices / sequence specialties |
Also accepts: workforce/DE, workforce-UI, devops, o11y, data engineer, etc.
Pods (roster presets)
Pod | Invoke | Members | Use when |
WEB |
| UI, FE, BE | User-facing product surface |
DP |
| DS, DE | Data products / metrics / marts |
AIP |
| DS, DE, ML, AI | Intelligence stack (RAG/agents/models) |
PLAT |
| OPS, SRE, MON | Delivery + reliability + telemetry |
SHIP |
| SEC, BE, FE, QA | Release hardening / gates |
Pods run member POVs + a delegation table, then you execute one workforce/FLAG. See docs/ADR-0001-pods.md.
Tools
Tool | Purpose |
| Primary — load full specialist context for the work |
| Alias of |
| Catalog of flags + specialties |
| Catalog of pods (WEB / DP / AIP / …) |
| Run a pod brief (roster → delegate → first FLAG) |
| Mid-task check against a specialty’s bars |
| Switch context (e.g. ARCH→FE, DE→AI) |
| Multi-specialty meeting (incl. postmortem_theater) |
| Manager ownership plan — who owns which slice, in what order |
Default mode=ask: investigate the repo, then reply with Goal / Blocking questions (0–3 with defaults) / Assumptions / Plan and stop until approved (unless the change is trivially small).
Example prompts to your agent
workforce/UI— design the marketing landing pageworkforce/WEB— plan a web feature across UI → FE/BEworkforce/DP— plan a data mart with DS + DEworkforce/AIP— plan RAG/agent work (not the same asworkforce/AIalone)workforce/DE— design the orders gold martworkforce_aswith roleSRE— define SLOs for checkoutworkforce/discuss— scrum the “express checkout” idea across specialtiesworkforce/discusswith formatpostmortem_theater— full cast; each specialty owns one corrective actionworkforce/delegate— break “express checkout” into specialty-owned slicesworkforce/MGR— stay in manager mode and sequence the workPlain language also works: “Load DE context and design the orders gold mart”
Switch context OPS → SRE after the golden path is ready
How Workforce differs from skill directories (e.g. skills.sh)
skills.sh is a marketplace of discrete skills you install one-by-one (npx skills add …) — procedural snippets for agents (frontend-design, tdd, azure-*, etc.). That model wins at breadth and remixing many tiny capabilities.
Workforce is a different bet:
Skill directories | Workforce | |
Unit | One skill file / procedure | One specialty with identity, stack defaults, quality bars, anti-patterns, handoffs |
How you use it | Install many skills into the agent | One MCP — call |
Coordination | You pick which skills to stack | Discuss → delegate → one specialty at a time → handoff |
Failure work | Separate debugging / review skills | Postmortem theater: every specialty owns one corrective action |
Intake | Often “just do it” | Contractor Goal / Blocking questions / Assumptions / Plan before high blast-radius work |
Be better, not broader: stay opinionated on orchestration and bars; don’t become another skill dump. Complement skills.sh (use a skill for a niche procedure) while Workforce owns who speaks, who owns the slice, and when to switch.
Develop
npm install
npm run validate-packs
npm run build
npm run smokeLicense
MIT
Support
Having install or connection issues? Reach out:
Email: salilhiremath2712@gmail.com
GitHub issues: https://github.com/Saaalil/Workforce-MCP/issues
Available Tools
7 toolsworkforce_asLoad Specialist ContextARead-onlyIdempotent
Load full specialist context into the agent for a task (skills, stack defaults, quality bars, anti-patterns, handoffs). The agent must investigate the repo, then reply with Goal / Blocking questions (0–3 with defaults) / Assumptions / Plan and stop until approved (unless the change is trivially small). Use when the user says workforce/UI, workforce/DE, DE, Backend, SRE, Ops, etc. This is NOT hiring people — it equips the agent to do that specialty of work at full potential. Short flags: DE UI FE BE DS ML AI ARCH OPS SRE MON SEC QA MGR. Orchestration: workforce_discuss, workforce_delegate.
| Name | Required | Description | Default |
|---|---|---|---|
| mode | No | ask (default): investigate then Goal/Blocking questions/Assumptions/Plan and stop; plan: same with a concrete plan; execute: implement after approval | |
| role | Yes | Specialist context to load — short flag or full id. Examples: DE, UI, FE, BE, DS, ML, AI, ARCH, OPS, SRE, MON, SEC, QA, MGR or data_engineer, ui_designer, frontend, backend, ops, sre, monitoring, security, qa, manager. Also accepts workforce-DE / workforce/UI / workforce/MGR style strings. This loads agent context for the work — it does not hire people. | |
| task | Yes | The work to do under this specialist context | |
| context | No | Optional repo/product/background notes | |
| constraints | No | Optional stack, deadline, brand, compliance, or budget constraints |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only and idempotent behavior, and the description adds process transparency: the agent must investigate the repo, reply with Goal/Blocking questions/Assumptions/Plan, and stop until approved (unless trivially small). This goes beyond the annotations by disclosing the expected workflow and stopping condition.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the main purpose and immediately explains key behavior, then usage, clarifications, and flags. It is dense but every sentence serves a purpose; a minor deduction for slightly packed phrasing that could be streamlined without losing information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the absence of an output schema, the description sufficiently explains what the agent should return (Goal/Blocking questions/Assumptions/Plan). It also covers triggers, exclusions, role flag syntax, and orchestration context, making the tool's behavior complete for an agent to select and invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already covers all parameters with descriptions (100% coverage), so baseline is 3. The description adds value by listing short flags (DE, UI, FE, etc.), clarifying that the role parameter loads context rather than hiring, and implicitly explaining the mode behavior through the overall process description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb+resource pair ('Load full specialist context into the agent for a task') and enumerates what the context contains (skills, stack defaults, quality bars, anti-patterns, handoffs). It also differentiates from siblings by explicitly stating 'This is NOT hiring people' and referencing orchestration tools, making its unique role clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit trigger phrases ('Use when the user says workforce/UI, workforce/DE, DE, Backend, SRE, Ops, etc.'), an exclusion ('This is NOT hiring people'), and points to related tools for orchestration (workforce_discuss, workforce_delegate). This gives clear when-to-use and when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
workforce_consultConsult Specialist ContextARead-onlyIdempotent
Mid-task check against an already-loaded specialty's quality bars and decision frameworks (short flag or full id). Not hiring — specialist judgment for a blocker or decision.
| Name | Required | Description | Default |
|---|---|---|---|
| goal | No | What good looks like for this consult | |
| role | Yes | Specialist context to load — short flag or full id. Examples: DE, UI, FE, BE, DS, ML, AI, ARCH, OPS, SRE, MON, SEC, QA, MGR or data_engineer, ui_designer, frontend, backend, ops, sre, monitoring, security, qa, manager. Also accepts workforce-DE / workforce/UI / workforce/MGR style strings. This loads agent context for the work — it does not hire people. | |
| situation | Yes | Current situation, blocker, or decision point |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and idempotentHint=true, so the boundary of safety is covered. The description adds that it relies on an already-loaded specialty and provides judgment, not hiring, which is useful behavioral context beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the primary action ('Mid-task check') and includes the critical 'Not hiring' qualifier. There is no redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 3 parameters with full schema descriptions and annotations cover safety. The description explains the purpose, the dependency on an already-loaded specialty, and the output nature ('specialist judgment'), making it complete enough for selection and invocation, though it doesn't detail response format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and the schema's role field already explains accepted formats and that loading context does not hire people. The tool description adds nothing beyond the schema, so a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it performs a mid-task consult against an already-loaded specialty's quality bars and decision frameworks. It uses a specific verb ('check') and distinguishes from hiring tools by saying 'Not hiring,' which sets it apart from siblings like workforce_delegate.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description indicates use when there's a mid-task blocker or decision and specialist judgment is needed. It explicitly clarifies it is not for hiring, excluding an alternative use, and implies the specialty context must already be loaded, aligning with workforce_specialize as a preceding tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
workforce_delegateDelegate across specialtiesARead-onlyIdempotent
Manager-style work breakdown: which specialty owns which slice, in what order, with acceptance criteria and workforce/FLAG invoke hints. Use after discuss or when the user asks who should do what.
| Name | Required | Description | Default |
|---|---|---|---|
| goal | Yes | Outcome to deliver | |
| roles | No | Optional comma-separated specialty subset to consider | |
| context | No | Optional product/repo background | |
| constraints | No | Deadline, stack, compliance, scope cuts |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds behavioral context by mentioning 'workforce/FLAG invoke hints' and acceptance criteria, which reveals the output nature. It does not contradict annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose, and includes a concise usage hint. No filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a planning tool with no output schema, it conveys purpose, usage context, and key output elements. It lacks a comparison to sibling tools but is reasonably complete for its complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with all four parameters having descriptions in the schema. The tool description itself does not elaborate on parameters, so per the rubric it relies on the high schema coverage; baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb+resource: 'Manager-style work breakdown' that determines 'which specialty owns which slice, in what order, with acceptance criteria and workforce/FLAG invoke hints.' This clearly distinguishes it from sibling tools like list_roles or handoff by focusing on decomposition and ownership assignment.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit when-to-use guidance: 'Use after discuss or when the user asks who should do what.' It gives the trigger context but does not name alternatives or when not to use, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
workforce_discussMulti-specialty discussARead-onlyIdempotent
Run a multi-role discussion on an idea (scrum, critique, premortem, war room, retro, design review, or postmortem theater). Surfaces challenges from each specialty POV, then recommends a sequence — not hiring, not parallel implement-everything.
| Name | Required | Description | Default |
|---|---|---|---|
| roles | No | Optional comma-separated specialties (e.g. UI,FE,BE,SEC). Ignored for postmortem_theater (full cast always). | |
| topic | Yes | Idea, feature, incident, or decision to discuss | |
| format | No | scrum (default) | critique | premortem | war_room | retro | design_review | postmortem_theater | |
| context | No | Optional product/repo background |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, setting a low bar. The description adds behavioral context by disclosing that it 'Surfaces challenges from each specialty POV, then recommends a sequence,' and clarifies it will not hire or parallel-implement. This goes beyond the annotations to describe the tool's mode of operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two front-loaded sentences with no redundant wording. The first sentence states the action and formats, the second clarifies output and non-goals. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema, but the description explains the key output ('recommends a sequence') and enumerates all supported formats. It does not describe the return format in detail, but for a discussion tool the essentials are covered. The schema handles parameter details and defaults, so the description is sufficient for an agent to select and invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description does not add syntax or parameter-specific detail beyond what the schema already provides; it only refers abstractly to 'specialty POV' and lists formats already in the enum. Thus no significant additional semantic value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Run a multi-role discussion on an idea,' and lists the exact discussion formats. It also distinguishes itself from siblings by explicitly stating what it is not for ('not hiring, not parallel implement-everything').
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use when a multi-role discussion is needed and provides exclusions with 'not hiring, not parallel implement-everything.' However, it does not explicitly name alternative sibling tools or state 'use this instead of X'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
workforce_handoffSwitch Specialist ContextARead-onlyIdempotent
Switch the agent's specialist context from one specialty to another (e.g. ARCH→FE, DE→AI, OPS→SRE) with a clean brief. Not a personnel handoff — a context switch so the next slice of work uses the right skills and quality bars.
| Name | Required | Description | Default |
|---|---|---|---|
| task | Yes | Work continuing under the new specialty context | |
| to_role | Yes | Incoming specialty. Specialist context to load — short flag or full id. Examples: DE, UI, FE, BE, DS, ML, AI, ARCH, OPS, SRE, MON, SEC, QA, MGR or data_engineer, ui_designer, frontend, backend, ops, sre, monitoring, security, qa, manager. Also accepts workforce-DE / workforce/UI / workforce/MGR style strings. This loads agent context for the work — it does not hire people. | |
| findings | No | Key findings and constraints from the outgoing specialty | |
| artifacts | No | Named artifacts to carry forward | |
| from_role | Yes | Outgoing specialty. Specialist context to load — short flag or full id. Examples: DE, UI, FE, BE, DS, ML, AI, ARCH, OPS, SRE, MON, SEC, QA, MGR or data_engineer, ui_designer, frontend, backend, ops, sre, monitoring, security, qa, manager. Also accepts workforce-DE / workforce/UI / workforce/MGR style strings. This loads agent context for the work — it does not hire people. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide safety signals (readOnlyHint=true, idempotentHint=true, destructiveHint=false), and the description adds valuable context beyond these: that this is a context switch (not a personnel action) and that it involves loading a 'clean brief' for the next slice of work. No contradictions are present.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences: the first states the action and gives concrete examples, the second clarifies the non-personnel nature and purpose. Every word earns its place, with no fluff or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a context-switch tool with strong annotations and a fully described schema, the description is complete: it defines the purpose, examples, and the key distinction from a personnel handoff. While it doesn't detail the return value, that is acceptable since there is no output schema and the tool is a simple state-change operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with each parameter already documented in detail (e.g., to_role and from_role have long explanations and examples). The description's role examples (ARCH→FE) add marginal context but do not meaningfully augment what the schema already provides, so the baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Switch'), the resource ('agent's specialist context'), and the direction ('from one specialty to another') with concrete examples (ARCH→FE, DE→AI, OPS→SRE). It explicitly distinguishes itself from a personnel handoff, making the purpose unambiguous and distinct from sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description indicates when to use the tool: when switching the agent's specialty context to apply the right skills and quality bars. It explicitly states 'Not a personnel handoff' to prevent misuse. However, it does not directly compare to sibling tools like workforce_as or workforce_specialize, leaving some room for ambiguity about alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
workforce_list_rolesList Specialist ContextsARead-onlyIdempotent
List all Workforce specialist contexts with short flags (DE, UI, SRE, …), full ids, aliases, and what each specialty owns. Use before workforce_as if unsure which specialist context fits the work. This is a context catalog — not a hiring roster.
| Name | Required | Description | Default |
|---|---|---|---|
| response_format | No | markdown for humans, json for structured parsing | markdown |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds semantic context that this is a catalog (not a hiring roster) and details the content of the listing, which is valuable beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the core function and content, and no filler. The exclusionary note ('not a hiring roster') earns its place by preventing misinterpretation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only list tool with one optional parameter and clear sibling context, the description sufficiently conveys what the tool returns and when to use it. It does not explain the response format, but the response_format parameter covers that, and no output schema is required for this simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter (response_format) has a full description and enum in the schema, so schema coverage is 100%. The description does not need to explain parameters; the schema carries the burden, and the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('List all Workforce specialist contexts') and enumerates the exact fields returned (short flags, full ids, aliases, ownership). It also distinguishes itself from being a hiring roster, clearly separating it from sibling tools that handle delegation or consultation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs to 'Use before workforce_as if unsure which specialist context fits the work', giving a clear when-to-use directive. It also states what the tool is not ('not a hiring roster'), providing an exclusion that helps rule out misuse.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
workforce_specializeLoad Specialist Context (alias)ARead-onlyIdempotent
Alias of workforce_as — load specialist context for the agent to perform specialized work. Not a hiring tool.
| Name | Required | Description | Default |
|---|---|---|---|
| mode | No | ask (default): investigate then Goal/Blocking questions/Assumptions/Plan and stop; plan: same with a concrete plan; execute: implement after approval | |
| role | Yes | Specialist context to load — short flag or full id. Examples: DE, UI, FE, BE, DS, ML, AI, ARCH, OPS, SRE, MON, SEC, QA, MGR or data_engineer, ui_designer, frontend, backend, ops, sre, monitoring, security, qa, manager. Also accepts workforce-DE / workforce/UI / workforce/MGR style strings. This loads agent context for the work — it does not hire people. | |
| task | Yes | The work to do under this specialist context | |
| context | No | Optional repo/product/background notes | |
| constraints | No | Optional stack, deadline, brand, compliance, or budget constraints |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds the useful behavioral note that it does not hire people, and clarifies the alias relationship with workforce_as, going beyond what annotations provide without contradicting them.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise—two short sentences—and every element earns its place: the alias reference, the purpose, and the hiring disclaimer. Zero wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The rich schema and annotations cover safety and parameter semantics. The alias to workforce_as provides a reference point for further details, and the hiring disclaimer addresses a likely misuse. Still, the description does not elaborate on what 'specialist context' entails or when to prefer this over other sibling tools, so a small gap remains.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so parameters are fully documented in the schema. The description adds no additional parameter-specific meaning, but it does not need to since the schema is complete. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool loads specialist context for the agent to perform specialized work. It uses a specific verb ('load') and resource ('specialist context'), and explicitly distinguishes itself from being a hiring tool, which aligns with sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description identifies this as an alias of workforce_as, which tells the agent it behaves identically to that sibling, providing clear usage context. It also notes 'Not a hiring tool' as an exclusion, but does not explicitly name alternatives or when-not-to-use scenarios beyond that.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
7 tool updates
v1.3.0- First observed
workforce_as - First observed
workforce_consult - First observed
workforce_delegate - First observed
workforce_discuss - First observed
workforce_handoff - First observed
workforce_list_roles - First observed
workforce_specialize
TDQS
Scored across 7 tools
Most tools are distinct, but workforce_as and workforce_specialize are explicitly aliases, creating a clear overlap. The descriptions help mitigate confusion, but the redundancy could still cause an agent to select the wrong one.
All tools share the workforce_ prefix, but the action part is inconsistent: list_roles is verb_noun, as is a preposition, handoff is a noun, while delegate, specialize, consult, and discuss are verbs. This mixed pattern lacks the predictable verb_noun structure expected.
Seven tools is well within the ideal range for a specialist context manager. Each tool serves a distinct purpose in the workflow, and the count feels appropriately scoped without excess or deficiency.
The tool set covers the full lifecycle: listing roles, delegating work, loading contexts, monitoring mid-task quality, switching between contexts, and running discussions. There are no obvious dead ends or missing operations for the domain it addresses.
Maintenance
Related MCP Connectors
Contextual prompts and agent skills for 140+ AI platforms.
Cross-tool persistent memory and context for AI assistants over MCP.
Your org's AI agents, tasks, runs, search, and brain files as MCP tools and resources.
MCP server for AI agent profiles and smart notes. 60+ coding prompt packs with expert personas.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceProvides AI agents with operational customer context, including typed revenue objects, persistent state, scoped tools, and human-in-the-loop handoffs through MCP, REST, and CLI.012Apache 2.0
- AlicenseNot gradedqualityDmaintenanceEnables AI coding agents to retrieve and manage code context with hybrid search, project memory, and observability via MCP tools.29MIT
- FlicenseNot gradedqualityCmaintenanceEnables AI agents to access a codebase context, select relevant files, and route queries to the appropriate AI model based on complexity, all through an MCP interface.-
- AlicenseNot gradedqualityDmaintenanceExposes a developer's local context (communication preferences, stack, repos, memory models) to AI agents via MCP tools and resources, enabling them to bootstrap with local guidelines and reduce context hallucination.MIT