agentleFS
robertfxbrrobertfxbr/mcp-orchestrator/SKILL.md

mcp-orchestrator

Skill0 starsChanged 4 months agoMITView on GitHub

Use when a task should be solved through MCP servers, connected tools, or external structured capabilities. Handles server selection, tool discovery, trust-aware invocation order, and result summarization so MCP use is predictable instead of ad hoc.

1 other project uses a version of this.

Adopted by

Most recently taken up by

  • Other versions1 project uses a version of this.

    Word for word · 0

    None found.

    Edited · 0

    None found.

    Wrote their own version · 1

    1. cobusgreyling/grok-build-arsenal★ 6same name

    How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.

The file

Show its rules and text

We split this skill into the rules it gives an agent

27 rules. About 0 are common, 23 are distinctive, and 4 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈23

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 4

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Use this skill after deciding that MCP is the right lane.

    line 10
  2. Very specific:

    if the environment requires tool_search for deferred or MCP tool discovery, use it

    line 19
  3. Distinctive:

    do not assume generic resource-listing calls are the right discovery path everywhere

    line 20
  4. Distinctive:

    Prefer read-only or low-scope tools before write-capable tools.

    line 23
  5. Distinctive:

    Keep a short running model of:

    line 25
  6. Distinctive:

    If the best MCP path fails, re-check discovery and assumptions once before deciding whether to fall back to a non-MCP path.

    line 31
  7. Distinctive:

    Prefer connector-native workflows when the user is targeting a connected system.

    line 36
  8. Distinctive:

    Avoid MCP if local tools can solve the task more simply and safely.

    line 37
  9. Distinctive:

    Use one MCP tool at a time unless parallelism is clearly independent.

    line 38
  10. Distinctive:

    If MCP adds friction without better access, correctness, or scope control, do not use it.

    line 40
  11. Distinctive:

    Prefer specific object-level tools over broad search or admin tools.

    line 45
  12. Distinctive:

    Avoid sending more user data than the selected tool needs.

    line 46
  13. Distinctive:

    If a tool schema is unclear, restate the intended arguments before calling it.

    line 47
  14. Distinctive:

    If a call fails because the tool or server assumptions were wrong, refresh discovery instead of retrying blindly.

    line 48
  15. Distinctive:

    If a write-capable tool is not clearly needed, stay with read-only inspection.

    line 49
  16. Very specific:

    Do not use this skill to justify MCP after safe-task-router or direct evidence shows local tools are better.

    line 53
  17. Distinctive:

    Do not skip discovery and jump straight to a guessed tool call.

    line 54
  18. Distinctive:

    Do not keep retrying the same failing tool with the same assumptions.

    line 55
  19. Distinctive:

    Do not combine server selection, trust review, and execution into one opaque step.

    line 56
  20. Distinctive:

    If a connected Google Drive or GitHub tool provides the exact object you need, MCP is likely the right path.

    line 61
  21. Distinctive:

    If the answer is already in local files or direct shell inspection, do not route through MCP just because a connector exists.

    line 62
  22. Distinctive:

    If the first MCP tool only helps you discover a more specific tool, stop and narrow before making broader calls.

    line 63
  23. Very specific:

    If trust, data exposure, or local execution risk becomes non-trivial, pair with secure-mcp-governor before mutating anything.

    line 64
  24. Distinctive:

    Treat stdio servers as local code execution surfaces.

    line 68
  25. Distinctive:

    Treat remote MCP endpoints as external trust boundaries.

    line 69
  26. Distinctive:

    Do not assume a server is safe just because it is available.

    line 70
  27. Distinctive:

    Keep the user-facing explanation brief:

    line 75

≈ “Common” is an estimate: at least 1 in 5 of the 350,495 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

MCP Orchestrator

Use MCP deliberately.

Use this skill after deciding that MCP is the right lane. Pair it with secure-mcp-governor whenever trust, data exposure, or local execution risk is non-trivial.

This skill ends once the correct MCP tool path is chosen, executed, and either verified or intentionally abandoned in favor of a safer non-MCP path.

Workflow

  1. Determine whether MCP is actually the best path.
  2. Identify candidate MCP servers relevant to the task.
  3. Discover available MCP tools using the environment's approved discovery mechanism.
    • if the environment requires tool_search for deferred or MCP tool discovery, use it
    • do not assume generic resource-listing calls are the right discovery path everywhere
  4. Inspect available tools before deciding on a call path.
  5. Narrow the list to the smallest plausible tools.
  6. Prefer read-only or low-scope tools before write-capable tools.
  7. Validate arguments against the tool schema before invocation.
  8. Keep a short running model of:
    • chosen server
    • chosen tool
    • expected output
    • trust level
  9. Invoke one tool at a time unless calls are truly independent.
  10. If the best MCP path fails, re-check discovery and assumptions once before deciding whether to fall back to a non-MCP path.
  11. Summarize results in task language, not just raw MCP output.

Selection Rules

  • Prefer connector-native workflows when the user is targeting a connected system.
  • Avoid MCP if local tools can solve the task more simply and safely.
  • Use one MCP tool at a time unless parallelism is clearly independent.
  • Re-check available tools when the server context changes.
  • If MCP adds friction without better access, correctness, or scope control, do not use it.

Call Discipline

  • List or inspect before mutate.
  • Prefer specific object-level tools over broad search or admin tools.
  • Avoid sending more user data than the selected tool needs.
  • If a tool schema is unclear, restate the intended arguments before calling it.
  • If a call fails because the tool or server assumptions were wrong, refresh discovery instead of retrying blindly.
  • If a write-capable tool is not clearly needed, stay with read-only inspection.

Boundary Rules

  • Do not use this skill to justify MCP after safe-task-router or direct evidence shows local tools are better.
  • Do not skip discovery and jump straight to a guessed tool call.
  • Do not keep retrying the same failing tool with the same assumptions.
  • Do not combine server selection, trust review, and execution into one opaque step.
  • Re-route out of MCP if discovery shows no tool with a clear advantage for the task.

Boundary Examples

  • If a connected Google Drive or GitHub tool provides the exact object you need, MCP is likely the right path.
  • If the answer is already in local files or direct shell inspection, do not route through MCP just because a connector exists.
  • If the first MCP tool only helps you discover a more specific tool, stop and narrow before making broader calls.
  • If trust, data exposure, or local execution risk becomes non-trivial, pair with secure-mcp-governor before mutating anything.

Trust-Aware Operation

  • Treat stdio servers as local code execution surfaces.
  • Treat remote MCP endpoints as external trust boundaries.
  • Do not assume a server is safe just because it is available.
  • Pair this skill with secure-mcp-governor whenever trust is not trivial.

Output

Keep the user-facing explanation brief:

  • why MCP was chosen
  • which server/tool was used
  • what came back
  • what the next best action is

Example:

  • why MCP was chosen: the task depends on a connected system that local files cannot access
  • which server/tool was used: selected the Google Drive server and a file-specific read tool
  • what came back: the target file metadata and current contents
  • what the next best action is: continue with a narrower read or switch back to local work if MCP is no longer needed

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.