Subagents & Skills
Two ways to keep a conversation focused: hand work to a subagent with its own context, and load a body of guidance only when it is needed.
Subagents
The Agent tool delegates a scoped task to a fresh agent with its own context window and its own allowlisted tool set. Only the final summary crosses back into the parent conversation.
Why it matters
Bulk reading is what fills a context window. Twenty files read inline cost twenty file contents in the parent's history, and every subsequent turn pays for them. The same twenty read by a subagent cost one paragraph.
The agent is nudged toward delegation once inline reading has grown expensive. Suppress the nudge with --no-delegation-nudge.
What a subagent gets
| Context | Its own, starting from the task it was given |
| Tools | An allowlisted subset of the parent's registry |
| Sandbox | The same sandbox root and the same permission mode |
| Result | A single summary returned to the parent |
Nesting is bounded at one level
A subagent has no Agent tool. The tool set a subagent can reach is a snapshot of the registry taken before Agent was added to it.
That makes the bound structural rather than a rule someone has to remember: a subagent cannot dispatch a subagent because the tool is not there to call, and that holds even if allowlists change later.
Watching a subagent work
Over the control protocol, tool_use and tool_result events raised inside a subagent carry a parent field naming the dispatching tool call. A client can render subagent activity nested under the call that started it, rather than interleaved into the main stream.
When to reach for one
| Situation | Delegate? |
|---|---|
| "Read these thirty files and tell me which ones touch the Modbus map" | Yes. The reading is the cost |
| "Search the codebase for every caller of this function" | Yes |
| "Fix this one function" | No. The parent already has the context |
| "Run the test suite" | No. That is a job |
Delegation trades a round trip for context. It pays when the work produces far less output than it consumes.
Skills
A skill is a body of guidance the agent loads on demand through the Skill tool. Skills are not code. They are written instructions for a task, with a description that tells the agent when to reach for them.
Why they are not just prompt text
Everything in the system prompt costs tokens on every turn and is part of the cache key. A skill costs nothing until it is loaded, and loading it does not disturb the prefix.
Skill bodies are pinned against compaction. Once loaded, the guidance survives for the rest of the conversation, since losing it halfway through a procedure would change what the agent believes it is doing.
Skills that ship with the checks catalogue
| Skill | Use when |
|---|---|
check-triage | After running Check or Audit, before reporting results. What each verdict and confidence class licenses you to claim, and the fix-and-re-run loop |
rt-provisioning | A machine needs to become real-time capable. Choosing between a distro RT kernel, mainline PREEMPT_RT, and runtime preemption switching, and knowing which of those a vendor-kernel board can take |
rt-tuning | A machine fails its PREEMPT_RT checks, or jitter is over budget. Turning a report into the right fix in the right order |
rt-control-loop | Writing or reviewing a control program that has to hold a cycle time: scheduling, memory locking, the loop skeleton, safe state on overrun, exporting the loop's own timing |
rt-provisioning is about a box that cannot be real-time. rt-tuning is about a box that is wrong. rt-control-loop is about a program that is wrong. The agent picks between them from the descriptions.
In practice
You do not invoke a skill yourself. Ask for the outcome and the agent loads what it needs:
"This box fails
l3.rt.isolcpus-effective. Fix it."
The agent runs Check, loads rt-tuning, and works the fixes in the order that skill prescribes rather than the order the report happens to list them in.
Memory
Distinct from both. Memory is a persistent per-project store the agent can write to and read back in a later conversation.
| Location | ~/.local/state/oasis-agent/memory/<project> |
| Override | OASIS_MEMORY_DIR |
| Disable | --no-memory |
Memory is on by default. It costs one tool in the schema plus an index, both of which sit in the cached prompt prefix, so --no-memory is the escape hatch for a session that wants the leanest possible prefix, or that must not record anything.
The store lives outside the repository, so notes about a project do not end up in its git history.
Choosing between them
| You want | Use |
|---|---|
| Bulk work done without filling this conversation | A subagent |
| Procedural guidance for a task, loaded when relevant | A skill |
| Something remembered for next time | Memory |
| A long-running command | A job |
| A whole conversation running detached | A background agent |