Skills vs sub-agents: when to use each in AI systems

Key Takeaways

• Skills run within conversations with human-in-the-loop iteration; sub-agents execute independently and return final output
• Task frequency is the clearest decision signal: one-off work favors skills, repeatable batch jobs favor sub-agents
• Sub-agents introduce orchestration complexity and non-determinism that skills avoid

Azure lead engineer Kishorekumar Pattabiraman published guidance this month on a question that trips up teams building AI systems: should this capability be a skill or a sub-agent? The distinction matters more than model selection, Pattabiraman argues, because choosing wrong means no model will compensate. His framework identifies four dimensions that determine the answer.

What separates a skill from a sub-agent?

The two patterns serve different interaction models. A skill operates inside an ongoing conversation. It can read files, ask clarifying questions, iterate with the user, and keep a human engaged throughout execution. A sub-agent works differently: it accepts a single prompt, runs to completion on its own, and hands back a final result.

Neither is inherently better. Both fail when applied to the other's job. A skill forced into batch execution becomes clunky. A sub-agent shoved into an iterative conversation loses context between calls.

Four dimensions that determine the choice

Pattabiraman's framework rests on four criteria. The first three require weighing tradeoffs. The fourth, task frequency, draws the sharpest line.

Iteration model asks how much back-and-forth the task needs. Some work benefits from a conversation: the user refines requirements, the agent adjusts, both sides converge on the output. Other tasks need no refinement. They take inputs and produce outputs. Forcing iteration on a batch job wastes time. Forcing a single shot on exploratory work produces outputs that need correction anyway.

Voice fidelity concerns how closely the output must match a specific tone or style. Skills, by staying in conversation, can calibrate continuously. Sub-agents produce a final artifact that either hits the mark or doesn't.

Human gate placement defines where a person intervenes. A skill keeps the human engaged throughout. A sub-agent places the gate at handoff or review. The choice depends on risk tolerance and the cost of correction.

Frequency is the tiebreaker. Pattabiraman puts it bluntly: "A one-off craft piece leans to a skill, a repeatable batch job to a sub-agent." When you run the same task hundreds of times, the overhead of building and orchestrating a sub-agent pays off. When you run it once, a skill gets the job done without the infrastructure.

The context window tradeoff

Community discussions on Reddit and Hacker News surface a technical consideration Pattabiraman's post touches lightly: context pollution.

Reddit user enthusiast_bob points out that sub-agents always start clean. They don't inherit the parent conversation's context window. This isolation prevents earlier messages from confusing the task. A skill, by contrast, carries the full conversation. That's useful for continuity but risky when the context becomes long or noisy.

Another commenter, dan-does-ai, frames it differently. Skills win on reusability: you can port them across multiple agents or conversation flows. Sub-agents win when the step genuinely needs separate context, different permissions, or access to a distinct knowledge source. The architectural question becomes: does this task need isolation or continuity?

The orchestration tax

Sub-agents don't run themselves. They require an orchestration layer to invoke them, pass inputs, handle outputs, and manage failures. That layer adds complexity and introduces non-determinism.

Reddit commenter Ashlesha-msft describes the behavior in Microsoft's Copilot Studio. The planner decides dynamically when to call skills, tools, topics, or sub-agents. It bases that decision on descriptions, context, and recent conversation history. The result: a skill might not fire on every similar prompt. The same input can produce different execution paths.

For teams building production systems, this non-determinism creates testing challenges. You can't assume a sub-agent will run just because conditions look right. The orchestrator makes that call, and its reasoning isn't always transparent.

A mental model for the full stack

Reddit user Vlourenco69 offers an organizational analogy that maps these concepts to roles. An agent is a director. A sub-agent is a manager. A skill is a specialized worker. A tool is a dedicated machine. MCP (Model Context Protocol) represents the governance rules.

The analogy isn't perfect, but it captures the layering. Directors don't do the work themselves. They delegate to managers who coordinate workers. Workers use tools. Governance constrains everyone. When you're deciding whether to build a skill or a sub-agent, you're deciding whether this capability needs a manager or just a worker.

When the dichotomy breaks down

Pattabiraman's final point undercuts the apparent simplicity of his framework. In practice, he writes, the dichotomy is often false. The two models compose cleanly. A skill can invoke a sub-agent internally when part of the work benefits from isolation. A sub-agent can surface intermediate results through a skill interface.

This layered approach, Pattabiraman argues, represents the most mature design. The question isn't skill or sub-agent. It's which parts of this capability need which execution model, and how do they compose?

Teams building AI systems should treat the framework as a starting point. Map each capability to the four dimensions. Let frequency break ties. But expect to combine patterns as the system matures.

Frequently Asked Questions

When should I definitely use a skill over a sub-agent?

Use a skill when the task requires iterative refinement with user feedback, when maintaining conversation context matters, or when the work is a one-off craft piece rather than a repeatable job.

What's the main technical advantage of sub-agents?

Sub-agents start with a clean context window. They don't inherit the parent conversation's history, which prevents context pollution and allows isolated execution with different permissions or knowledge sources.

Can skills and sub-agents work together?

Yes. A skill can invoke a sub-agent internally for isolated batch work while maintaining the conversational interface. This layered pattern is often the most mature design for complex capabilities.

Source: InfoQ