# AI agent skills and subagents: fewer tokens, smaller models

> How skills and subagents beat one giant prompt: load know-how only when needed, split work into focused contexts, and route steps to smaller models.

By StellarFirm team. Published 2026-10-24. 7 min read.

Keywords: agent skills, subagents, ai token cost, small language models, open source models, model routing, context window
Tools covered: StellarFirm, Claude Code

## Key takeaways

- One big prompt to one big model gets slower and costlier as the conversation grows, because every turn carries the whole context.
- Skills package instructions, scripts, and reference files and load them only when a task needs them, and scripts do deterministic work without spending model tokens.
- Subagents get a fresh, small context for a focused subtask, can run in parallel, and return only a summary, which keeps the main context clean.
- With a good skill and a narrow subtask, a smaller or open weight model can do steps that would otherwise need a strong one, while a strong model plans and reviews.

Skills and subagents let an AI agent solve a complex problem without pushing everything through one giant prompt to one expensive model. A skill loads know-how only when a task needs it, and a subagent handles a focused piece of work in its own small context. Together they make agents faster to run, cheaper in tokens, and able to use smaller models for the right steps. This guide explains the mechanisms and shows how to apply them, without promising numbers we cannot source.

## Why is one big prompt to one big model a problem?

A single long conversation gets heavier with every turn, because the model re-reads the whole context each time. Longer context means more tokens to process, more latency, and more noise for the model to sort through.

Typical symptoms:

- Instructions for every possible task sit in the prompt, whether needed or not.
- Tool output, file contents, and dead ends pile up in the history.
- The strongest, costliest model does easy steps that a smaller one could handle.
- One failed step can derail the whole conversation.

The fix is not a bigger window. It is to put the right information in front of the model at the right time, and to hand narrow work to focused workers.

## What are skills and how do they save tokens?

A skill is a package of instructions, optional scripts, and reference files that an agent loads only when a task calls for it. Anthropic's documentation describes this as progressive disclosure: the agent first sees only each skill's short name and description, and reads the full instructions and extra files when the skill is relevant.

Three mechanisms matter:

| Mechanism | What it does | Why it helps |
| --- | --- | --- |
| Progressive disclosure | Only a short description is always loaded; full instructions load on demand | Idle skills cost almost nothing |
| Bundled scripts | A script does a deterministic job, such as parsing a file or validating a format | The model runs it and reads the result instead of reasoning through it in tokens |
| Reference files | Long material sits in files the skill points to | It is read only when a step needs it |

Skills also make work repeatable. The procedure is written once, reviewed by a person, and followed the same way each time, which matters more than any single saving. The open Agent Skills format is described at agentskills.io, and the same idea appears across several agent tools.

## What are subagents and when do they help?

A subagent is a separate agent with its own fresh context that an orchestrator hands a focused subtask. It does the work and returns a summary, so the details never fill the main conversation. Claude Code documents this pattern, with subagents defined by a name, a description, and their own instructions.

What this buys you:

- **A small, clean context.** The subagent sees the brief and the files it needs, not the whole history.
- **Parallelism.** Independent subtasks can run at the same time.
- **A clean main thread.** Only the summary comes back.
- **Specialization.** Each subagent can have its own instructions and, where a tool allows it, its own model.

Good subagent jobs are independent and checkable: search a codebase for every use of a function, review one file against a checklist, or research one question. Poor ones depend on each other's half finished output.

```prompt title="Split a task into subagent briefs"
I want to [overall goal]. Split it into independent subtasks that could run in parallel. For each subtask write a self contained brief with: the goal, the files or sources it may use, the limits, how to know it is done, and the format of the summary to return. Then say what you will do yourself after the summaries come back.
```

## Which model should do which step?

Use a strong model to plan and review, and smaller or open weight models for narrow, well specified steps. A good skill is what makes a small model reliable: it replaces open ended judgment with a clear procedure.

| Task type | Suggested model size | Why |
| --- | --- | --- |
| Planning, decomposition, ambiguous goals | Large, strong model | Needs judgment and broad knowledge |
| Final review and risky decisions | Large, strong model | Errors here are expensive |
| Following a written procedure | Small or mid size open model | The skill supplies the thinking |
| Extracting fields, classifying, tagging | Small open model | Narrow, easy to check |
| Summarizing one document | Small or mid size model | Bounded input and output |
| Formatting, renaming, boilerplate code | Small open model | Low ambiguity |
| Searching and filtering results | Small open model plus scripts | Mostly mechanical |

Open weight families such as Qwen, DeepSeek, GLM, Mistral, and Llama have models in the smaller sizes that are widely used for steps like these. Capabilities change quickly, so test a candidate model on your own task with a few real examples before trusting it, and keep a stronger model as the reviewer.

```prompt title="Pick the smallest model for each step"
Here is my workflow: [steps]. For each step, say whether it needs a strong model or whether a smaller or open weight model would likely do, and explain why in one line. Flag the steps where a mistake would be costly and a stronger model or a human should review the result.
```

## How does StellarFirm apply these ideas?

StellarFirm builds the pattern in. Your goal goes to the CEO assistant, which writes a short brief and hands it to the right assistant, so each worker starts from a focused brief instead of the whole conversation. A goal that needs several roles is planned across assistants, and each works in its own private workspace. See [How the CEO works](/docs/ceo/how-the-ceo-works) and [routing](/docs/ceo/routing).

Assistants also have skills, the step by step playbooks they follow for common jobs, such as the Coder's fix CI or review a pull request. An assistant picks the right skill from your message, and skills are built in, so you do not have to manage them. See the [Coder page](/docs/personas/coder) for the full list.

On models, each answer shows which model wrote it, whether Auto picked it, and the credits it used. After the 14 day trial your account stays on the free plan, where assistants keep working on the open models, and the premium models come with a paid plan. See [how credits work](/docs/credits/how-credits-work).

Approve still applies whatever model does the work: anything that sends, deploys, charges, publishes, or creates waits for you. See [Approvals](/docs/ceo/approvals).

```prompt title="Ask the CEO to split work across assistants"
CEO, my goal is [goal]. Plan it across the assistants I have: the steps in order, who does each one, what each hands to the next, and every step that needs my approval. Keep each assistant's brief short and self contained.
```

## How do I write my first skill?

Write one skill for one repeatable job, and keep it short. The format used across agent tools is a folder with a SKILL.md file whose top section gives a name and a description, followed by the instructions. Check your tool's documentation for the exact fields it supports.

1. **Pick a job you repeat**, such as "prepare release notes" or "triage a support ticket".
2. **Write the description first.** One or two sentences that say what the skill does and when to use it, because the agent decides whether to load it from this text.
3. **Write the procedure as numbered steps**, in the order a careful person would do them.
4. **Move long reference material into separate files** and point to them from the steps.
5. **Turn mechanical steps into scripts**, such as a validator, so the model runs them instead of reasoning through them.
6. **Add a check**: how the agent knows the job is done and what to report.
7. **Test it** on three real examples, with a smaller model first, and fix the steps where it goes wrong.

A sample SKILL.md:

```markdown
---
name: release-notes
description: Draft release notes from merged pull requests since the last tag. Use when asked to prepare, write, or update release notes.
---

# Release notes

## Steps
1. List the pull requests merged since the last tag. Use `scripts/list_merged.sh` if it exists.
2. Group them under Added, Changed, and Fixed.
3. Write one plain sentence per item. Name the user visible effect, not the code.
4. Skip pull requests labeled internal.
5. Check each sentence against the pull request title. Do not add claims the title does not support.

## Output
A Markdown list grouped as above, then a short list of items you were unsure about.

## Reference
See `reference/style.md` for tone and wording rules.
```

```prompt title="Draft a skill from a workflow I describe"
I want to turn this workflow into a reusable skill: [describe the steps you do, the inputs, and what a good result looks like]. Write a SKILL.md with a one or two sentence description that says when to use it, numbered steps, an output format, and a check at the end. Point out which steps could become a script, and which need judgment that a smaller model might get wrong.
```

## How do I stay honest about savings?

Measure your own jobs instead of trusting round numbers. The mechanisms above are real, but the size of the saving depends on the task, the model, and how well the skill is written.

A simple test:

1. Run the job the old way, as one long prompt, and note the credits or tokens used, the time, and the quality.
2. Run it with a skill, then with a skill plus a smaller model for the narrow steps.
3. Compare cost, time, and quality together. A cheaper run that needs rework is not cheaper.
4. Keep a stronger model or a person reviewing anything risky.

If you are new to agents, start with [what is an AI agent assistant](/blog/what-is-an-ai-agent-assistant), and for approval design read [approval workflows for AI agents](/blog/approval-workflows-for-ai-agents).

## Frequently asked questions

### What is an agent skill?

A skill is a packaged unit of know-how: a SKILL.md file with a short description and instructions, plus optional scripts and reference files. The agent reads the description first and loads the rest only when a task calls for it.

### What is a subagent?

A subagent is a separate agent with its own fresh context that an orchestrating agent hands a focused subtask. It does the work and returns a summary, so the main conversation does not fill up with the details.

### Do skills and subagents really save tokens?

They reduce waste through specific mechanisms: loading instructions on demand, running scripts instead of reasoning through them, and keeping detailed work out of the main context. How much you save depends on the task, so measure your own jobs.

### Can smaller open source models do agent work?

For narrow, well specified steps they often can, especially when a skill spells out the procedure. Planning, ambiguous judgment, and final review are usually better left to a stronger model.

## Sources

- [Anthropic docs: Agent Skills overview](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview)
- [Agent Skills](https://agentskills.io/)
- [Claude Code documentation: Subagents](https://code.claude.com/docs/en/sub-agents)

---

Source: https://stellarfirm.ai/blog/skills-and-subagents-fewer-tokens-smaller-models