AI agent skills and subagents: fewer tokens, smaller models

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:

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.

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.

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.

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 and 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 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.

Approve still applies whatever model does the work: anything that sends, deploys, charges, publishes, or creates waits for you. See Approvals.

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:

---
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.

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, and for approval design read approval workflows for AI agents.