When Should I Use Skills vs Subagents on My Agent?

Last updated: August 21, 2026

Skills and subagents solve different problems. Use skills when you want to teach your agent a process it should follow in 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 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 — attached skills add almost nothing until one is needed

How They Actually Work (Under the Hood)

Skills: Instructions That Load on Demand

A skill is a folder of files in your agent's sandbox (a SKILL.md playbook, plus optional templates and scripts). Create and manage them from Skills, or add them on the agent itself. When a conversation starts, a custom agent sees the names and descriptions of attached skills — not the full instructions. When the task matches a skill, the agent reads the full skill into its context window and follows it.

Key behaviors:

Same context window — skill instructions load 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 name and description are available up front. The full instructions load only when relevant, which saves 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, including calling integrations through code.
Shareable — the same skill can be attached to multiple agents so they all follow the same process.
Self-improving — if AI Skill Editing is on, the agent can update the skill after you correct it, so the playbook improves over time.

On the general agent, skills are discovered on demand instead of listed up front. See How Skills Work Differently on the General Agent vs. Custom Agents.

Subagents: Independent Agents That Run Separately

When your agent invokes a subagent, it starts 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. For setup steps, see How Do Subagents Work and How Do I Set Them Up?.

Key behaviors:

Fresh context window — each subagent starts clean. The parent's conversation history is not carried over. Files are not copied automatically — the parent must explicitly transfer any files the subagent needs.
Parallel execution — you can spawn multiple subagents at once. They run concurrently, and the parent collects results as they finish. How many can run at once depends on your plan.
Two types:
- Self-clones ((Me)) — copies of the same agent, enabled by default. Useful for parallelizing identical work. You can also limit a clone to a subset of the parent's apps.
- Other agents — purpose-built specialists you've added to the agent's Subagents list. Each has its own tools, instructions, and skills.
Own time budget — each subagent runs with its own time budget (about half the parent agent's). It is not a 15-minute hard cap.
Clone depth limit of 1 — a self-clone cannot clone itself again. Cross-agent chains (Agent A → Agent B → Agent C) have no depth limit.
Visible in chat history — every subagent conversation appears in 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 (Me) 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 the parent's tools (optionally a subset); 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 conversation with its own credit cost
Setup effort	Create a skill and attach it	Self-clones (`(Me)`) are on by default. For specialists, add agents 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.