When Should I Use Skills vs Subagents on My Agent?
Last updated: April 29, 2026
Skills and subagents solve different problems. Use skills when you want to teach your agent a process it should follow within the current conversation (templates, playbooks, domain knowledge). Use subagents when you need the agent to delegate work to a separate agent that runs independently — either to parallelize tasks or to call on a specialist agent built for a different domain.
The Quick Decision Guide
| You want to… | Use | Why |
|---|---|---|
| Give your agent a step-by-step process (e.g., "follow our outreach sequence") | Skill | Skills inject instructions into the current conversation — no extra agent needed |
| Provide templates, formatting rules, or domain knowledge | Skill | Skills load on demand and keep this knowledge available without bloating every message |
| Speed up work by doing multiple things at once (e.g., research three competitors simultaneously) | Subagent (self-clone) | Each clone runs in parallel with its own context — your agent collects results when they finish |
| Hand off a task to a purpose-built specialist (e.g., "ask the Sales agent to pull CRM data") | Subagent (invoke other agent) | The specialist has its own tools, instructions, and skills tuned for that domain |
| Reuse the same process across multiple different agents | Skill | Attach the same skill to any agent — each agent follows the process consistently |
| Coordinate a team of agents (sales, marketing, support) from one place | Subagent (invoke other agents) | A coordinator agent delegates to specialists and combines their results |
| Keep the agent's context small and fast for simple conversations | Skill | Skills only load when relevant — 20 skills attached means nothing extra until one is needed |
How They Actually Work (Under the Hood)
Skills: Instructions That Load on Demand
A skill is a file (or folder of files) that lives in your agent's sandbox. When a conversation starts, the agent sees the names and descriptions of all attached skills — but not the full instructions. When the agent recognizes a task that matches a skill's description, it reads the full skill into its context window and follows the instructions.
Key behaviors:
- Same context window — skill instructions are loaded into the current conversation, not a separate one. They consume tokens in the agent's context, just like your messages do.
- Lazy loading — only the skill description is loaded upfront (~1-2 sentences). The full instructions load only when relevant, saving tokens on conversations that don't need that skill.
- Can include scripts — skills can contain Python scripts in a
scripts/folder. The agent can run these in the sandbox, which means skills can call integrations (Gmail, Sheets, Slack, etc.) through code. - Shareable — the same skill can be attached to multiple agents so they all follow the same process.
- Self-improving — agents can update their own skills over time if skill editing is enabled.
Subagents: Independent Agents That Run Separately
When your agent invokes a subagent, it spawns a completely separate agent conversation. That subagent gets its own context window, its own sandbox, and its own set of tools. When it finishes, the results come back to the parent.
Key behaviors:
- Fresh context window — each subagent starts clean. The parent's conversation history isn't carried over (though files can be transferred).
- Parallel execution — you can spawn multiple subagents at once. They all run concurrently, and the parent waits for all of them to finish.
- Two types:
- Self-clones — copies of the same agent. Useful for parallelizing identical work. Enabled by default on all agents.
- Other agents — purpose-built specialists you've added to the Subagents list. Each has its own tools, instructions, and skills.
- 15-minute timeout — each subagent has a 15-minute execution limit.
- Clone depth limit of 1 — a self-clone cannot clone itself again. But cross-agent chains (Agent A → Agent B → Agent C) have no depth limit.
- Visible in chat history — every subagent's conversation appears in your agent's chat history, so you can see exactly what it did.
Common Patterns
Pattern 1: Skill for a repeatable process
You want your agent to always follow a specific process when drafting proposals. Create a skill called proposal-writer with your template, formatting rules, and approval criteria. The agent loads it when someone says "draft a proposal" and follows the steps every time.
Why not a subagent? There's no delegation needed — the agent handles everything in one conversation. A skill keeps the process in context without the overhead of spawning a separate agent.
Pattern 2: Subagent for parallel research
You want your agent to research five companies at once. The agent spawns five self-clones, each researching a different company. All five run simultaneously, and the parent collects and summarizes the results.
Why not a skill? A skill can't run in parallel — it's instructions in one conversation. To do five things at once, you need five separate agents running at the same time.
Pattern 3: Subagent for cross-domain coordination
You have a lead qualification agent that needs CRM data and marketing engagement data. You've built a "Sales Research" agent connected to Salesforce and a "Marketing Insights" agent connected to HubSpot. The coordinator invokes both as subagents, gets their reports, and combines them into a qualification summary.
Why not skills? Each specialist agent has its own tools and context optimized for its domain. Putting all that knowledge and all those tools in one agent would make it slower and less focused.
Pattern 4: Skill + subagent together
Your coordinator agent has a skill that defines how to qualify leads (scoring criteria, escalation rules). It uses that skill to decide which subagents to invoke and how to evaluate their results. The skill provides the decision framework; the subagents provide the data.
Key Differences at a Glance
| Skills | Subagents | |
|---|---|---|
| What it is | Instructions/knowledge injected into the current conversation | A separate agent running independently |
| Context | Shares the parent agent's context window | Gets its own fresh context window |
| Parallelism | No — runs sequentially in one conversation | Yes — multiple subagents run concurrently |
| Tools | Uses the parent agent's connected tools | Self-clones inherit parent's tools; other agents use their own |
| Best for | Processes, templates, domain knowledge, formatting rules | Parallel work, domain specialists, complex coordination |
| Credit cost | Adds tokens to the parent agent's context (loaded text counts toward AI credits) | Each subagent is a separate AI interaction with its own credit cost |
| Setup effort | Create a skill and attach it | Build a separate agent (or enable self-cloning) and add it to the Subagents list |
Still Need Help?
If you're not sure which approach fits your use case, reach out to support at support@gumloop.com.