Skip to main content
Glama
Saaalil
by Saaalil

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 task

Same 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

ui_designer

Product / UI design

FE

frontend

Frontend implementation

BE

backend

APIs / services

ARCH

architect

System architecture

DE

data_engineer

Pipelines / lakehouse / dbt

DS

data_scientist

Experiments / model specs

ML

ml_engineer

Model lifecycle / serving

AI

ai_engineer

RAG / agents / evals

OPS

ops

CI/CD / platform / IaC

SRE

sre

SLOs / incidents / reliability

MON

monitoring

OTel / dashboards / alerts

SEC

security

Threat model / authz / supply chain

QA

qa

Test strategy / release gates

MGR

manager

Delegate slices / sequence specialties

Also accepts: workforce/DE, workforce-UI, devops, o11y, data engineer, etc.

Pods (roster presets)

Pod

Invoke

Members

Use when

WEB

workforce/WEB

UI, FE, BE

User-facing product surface

DP

workforce/DP

DS, DE

Data products / metrics / marts

AIP

workforce/AIP

DS, DE, ML, AI

Intelligence stack (RAG/agents/models)

PLAT

workforce/PLAT

OPS, SRE, MON

Delivery + reliability + telemetry

SHIP

workforce/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

workforce_as

Primary — load full specialist context for the work

workforce_specialize

Alias of workforce_as

workforce_list_roles

Catalog of flags + specialties

workforce_list_pods

Catalog of pods (WEB / DP / AIP / …)

workforce_pod

Run a pod brief (roster → delegate → first FLAG)

workforce_consult

Mid-task check against a specialty’s bars

workforce_handoff

Switch context (e.g. ARCH→FE, DE→AI)

workforce_discuss

Multi-specialty meeting (incl. postmortem_theater)

workforce_delegate

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 page

  • workforce/WEB — plan a web feature across UI → FE/BE

  • workforce/DP — plan a data mart with DS + DE

  • workforce/AIP — plan RAG/agent work (not the same as workforce/AI alone)

  • workforce/DE — design the orders gold mart

  • workforce_as with role SRE — define SLOs for checkout

  • workforce/discuss — scrum the “express checkout” idea across specialties

  • workforce/discuss with format postmortem_theater — full cast; each specialty owns one corrective action

  • workforce/delegate — break “express checkout” into specialty-owned slices

  • workforce/MGR — stay in manager mode and sequence the work

  • Plain 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 workforce/DE, discuss, delegate

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 smoke

License

MIT

Support

Having install or connection issues? Reach out:

Docs site: https://workforce-website-psi.vercel.app/support

Available Tools

7 tools
workforce_asLoad Specialist ContextA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
modeNoask (default): investigate then Goal/Blocking questions/Assumptions/Plan and stop; plan: same with a concrete plan; execute: implement after approval
roleYesSpecialist 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.
taskYesThe work to do under this specialist context
contextNoOptional repo/product/background notes
constraintsNoOptional stack, deadline, brand, compliance, or budget constraints

TDQS

A4.8/5.0
Behavior5/5

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.

Conciseness4/5

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.

Completeness5/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines5/5

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 ContextA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
goalNoWhat good looks like for this consult
roleYesSpecialist 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.
situationYesCurrent situation, blocker, or decision point

TDQS

A4.2/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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 specialtiesA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
goalYesOutcome to deliver
rolesNoOptional comma-separated specialty subset to consider
contextNoOptional product/repo background
constraintsNoDeadline, stack, compliance, scope cuts

TDQS

A4.2/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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 discussA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
rolesNoOptional comma-separated specialties (e.g. UI,FE,BE,SEC). Ignored for postmortem_theater (full cast always).
topicYesIdea, feature, incident, or decision to discuss
formatNoscrum (default) | critique | premortem | war_room | retro | design_review | postmortem_theater
contextNoOptional product/repo background

TDQS

A4.2/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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 ContextA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
taskYesWork continuing under the new specialty context
to_roleYesIncoming 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.
findingsNoKey findings and constraints from the outgoing specialty
artifactsNoNamed artifacts to carry forward
from_roleYesOutgoing 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

A4.2/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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 ContextsA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
response_formatNomarkdown for humans, json for structured parsingmarkdown

TDQS

A4.4/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines5/5

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)A
Read-onlyIdempotent

Alias of workforce_as — load specialist context for the agent to perform specialized work. Not a hiring tool.

ParametersJSON Schema
NameRequiredDescriptionDefault
modeNoask (default): investigate then Goal/Blocking questions/Assumptions/Plan and stop; plan: same with a concrete plan; execute: implement after approval
roleYesSpecialist 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.
taskYesThe work to do under this specialist context
contextNoOptional repo/product/background notes
constraintsNoOptional stack, deadline, brand, compliance, or budget constraints

TDQS

A4.2/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

  1. 7 tool updatesv1.3.0
    • First observedworkforce_as
    • First observedworkforce_consult
    • First observedworkforce_delegate
    • First observedworkforce_discuss
    • First observedworkforce_handoff
    • First observedworkforce_list_roles
    • First observedworkforce_specialize

TDQS

A4.1/5.0

Scored across 7 tools

Disambiguation3/5

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.

Naming Consistency2/5

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.

Tool Count5/5

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.

Completeness5/5

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

ActivitySlowing
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    D
    maintenance
    Provides 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.
    0
    12
    Apache 2.0
  • A
    license
    Not graded
    quality
    D
    maintenance
    Enables AI coding agents to retrieve and manage code context with hybrid search, project memory, and observability via MCP tools.
    29
    MIT
  • A
    license
    Not graded
    quality
    D
    maintenance
    Exposes 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