Index of every page on this site: llms.txt
All skills
minimax-ai avatar

/subagent-split-check

@0db1b4f
by MiniMaxminimax-ai/mcode-stack736 stars
50
Run it yourself

Decide whether a piece of work should go to a subagent or stay in the main agent loop. Use before spawning subagents, when designing a multi-agent architecture, or when auditing an existing set of subagents for merging back.

Use this Skill: https://skilld.dev/gh/minimax-ai/mcode-stack/subagent-split-check

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈62 tokens for metadata: the name and description. ≈828 when used: this file.

Description uses 3.1% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈247 characters, or 3.1%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Subagent Split Check

Subagents are a tool for managing context, not for dividing up territory. Default to one main loop with skills loaded on demand. Split only when one of the conditions below is clearly met.

Companion to MCode Engineering Notes 01, "More subagents isn't better". Plain-text checklist: checklists/subagent-split.md.

1. Is there a context reason to split?

Split is worth considering only if at least one is true:

  1. Measured degradation. The single loop gets measurably worse because its context grows. "Measured" means eval results, not a feeling.
  2. Parallel, disposable work. Several pieces of work can run in parallel, each needs a clean context, and each can be thrown away when done (for example independent research threads).
  3. Tool or instruction conflict. The main agent keeps picking the wrong tool, or its instructions conflict with each other.

Then ask the deciding question for the specific step: will we need the raw intermediate output later, or only a conclusion? Only "just the conclusion" work is a good fit for a subagent.

If the reason is "this belongs to another team" or "this is a different kind of question", do not split. That leads to lossy hand-offs between agents.

2. If you split, cut along context boundaries

  • The subtask barely depends on the rest of the system.
  • It returns a compact result (a verdict, a list, a small structured object).
  • Good examples: independent research threads, a component with a clear interface, a black-box verification step.
  • Expose the subagent to the main agent as a tool, so the main agent keeps the conversation with the user. Hand the whole conversation over only if the subagent truly has to talk to the user directly.

3. Before splitting, check the cheaper fixes

  • Too many tools? Merge tools by user intent and defer rarely used ones behind tool search (see tool-budget-audit).
  • Prompt too big? Turn procedures and rules into skills, actions and live data into tools, and reference material into something loaded on demand.
  • Worried about losing state? Write the plan, decisions and review conclusions into a design or progress doc (see handoff-doc). Once state lives in a file, the session can be cleared safely, and the urge to split "to protect context" mostly goes away.

4. Merging existing subagents back

If a system already has many subagents:

  1. Build a small end-to-end eval first. A handful of golden examples is enough to start.
  2. Merge the most frequently used, most tightly coupled ones first: those called back to back, reading and writing the same data, or feeding each other's input.
  3. During the transition, wrap remaining subagents as tools for the main agent, which also gives you a baseline.
  4. Merge one at a time: its prompt becomes a skill, its API calls become tools.
  5. Compare before and after. Look at which tasks flipped, not only the total score, and run each task more than once.
  6. Keep the subagent only if the merged version is measurably worse.

Use harness-experiment for the measuring discipline.

Output

Answer with: split or keep in the main loop, the condition that justifies it (or "none met"), where the boundary is if splitting, and what you would measure to confirm.

Source: SKILL.md on GitHub

No rule matched.

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

No alerts23d3 checks · Risk SAFE
  • Gen Agent Trust Hub23d

    The skill provides architectural guidelines for determining when to split tasks between agents. It contains no code, network operations, or sensitive data access.

  • Socket23d

    No alerts

  • Snyk23d

    Risk: LOW · No issues

Signed by skilld at 0db1b4f. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub last week.

Activeupdated 3 weeks ago

README badge

README badge for minimax-ai/mcode-stack/subagent-split-check