# AIClaw 3.12.13 Puts Explicitly Selected Skills Into the First Model Request

A community write-up describes a tagged release that injects a user's $skill-name selection into the outgoing request before any tool call, with separate token and byte budgets for the skill catalog and selected excerpts.

Canonical URL: https://freelancenews.online/news/aiclaw-3-12-13-puts-explicitly-selected-skills-into-the-first-model-2607c045
Published: 2026-11-22T11:18:18.127Z
Updated: 2026-11-22T11:18:18.127Z
Source published: 2026-11-20T00:05:40.000Z
Event date: Not established
Review status: source-reviewed
Review method: Automated comparison against retrieved source text; not independent fact-checking.

## Report

A community post on dev.to describes a behavior change in AIClaw version 3.12.13: when a user explicitly names a mounted skill in their message, the agent's kernel appends that skill's instructions to the outgoing request immediately, rather than waiting for the model to discover the skill through a catalog and fetch it with a tool call. The author frames the change around timing, arguing that a catalog is useful for discovery but that an explicit selection deserves a shorter path. The claims come from the post itself and are not independently verified here.

The distinction the author draws is between two workflows. In the first, a user asks something general, the model reads a catalog of available skills, and it decides whether to invoke a load_skill tool to retrieve instructions. In the second, the user has already made the choice by typing a complete $skill-name reference, and the post says the kernel matches that reference against mounted skills and places the selected text into the request before the model's first response or tool choice.

A mounted skill named release-check, together with a message like "$release-check summarize these changes," forms the worked example in the post. As described, those instructions can shape the model's first output with no prerequisite round trip needed to load the skill. Should the user simply request a summary instead, the post says the model may still find a suitable skill in the catalog and invoke load_skill when required, so the catalog route remains available.

Mechanically, the author says the kernel matches complete $skill-name references against mounted skills and appends the selected text to the outgoing request in memory, while the stored user message keeps its original text. That separation matters for anyone reasoning about transcripts: the selection is described as a request-assembly step, not a rewrite of what the user typed. The post also states that a retry after context compaction can still carry the selection, and that the next turn begins with fresh selection state.

Budgets are also set by the release. Per the post, up to 2,000 tokens is the estimated budget for the skill catalog, and that figure drops to 2 percent of the configured context window whenever the latter is smaller. Descriptions are shortened by AIClaw so that more names stay visible, and entries can be dropped if the names by themselves exceed the budget. Even when the catalog leaves out that entry, an exact reference to a mounted skill still works, the author notes, which is the practical benefit of matching selections apart from the catalog.

Selected skill text has its own limits: 8 KiB per skill excerpt and 32 KiB across all selected blocks, per the post. When a byte limit shortens an excerpt, the author says the model is directed to load_skill for more detail. These are described as prompt-assembly limits rather than model guarantees, and the post is explicit that supplying instructions does not ensure a model will follow them.

What the tests cover is also spelled out by the author. The kernel regression suite, per the post, inspects the requests a test model captures; its cases address whether the selection appears in the opening request, how it is scoped to a turn, a retry following compaction, the catalog's budget behavior, and truncation of UTF-8 text. What the kernel sends is established by those checks. Live-model instruction following, latency or provider token usage are not measured by them, the post states plainly — a boundary that matters for anyone treating the release notes as a performance claim.

For freelancers and developers building or operating agents, the described change is mostly about predictability of the first turn. If a workflow depends on a specific skill being active, an explicit reference is presented as a way to avoid spending the first model request on a discovery decision. The tradeoff is that the selection consumes request budget: the post's byte caps mean long skill instructions can be truncated, and truncation pushes the model back toward a load_skill call for the remainder.

There is also a context-window consideration. Because the catalog budget shrinks to 2 percent of the configured window when that is smaller than 2,000 tokens, agents configured with small windows will see a leaner catalog, and the post says entries can be omitted when names alone exceed the budget. Exact references are described as surviving that omission, but discovery of unselected skills becomes more dependent on what fits.

The post does not describe pricing, availability beyond the tagged release, or behavior across providers, and it does not report any measurement of whether models actually comply with injected instructions. It also does not compare this approach against alternatives beyond the catalog-and-tool-call path it describes. Readers should treat the version number, budgets and test scope as the author's account of a specific release rather than an audited specification.

A reasonable editorial reading is that this is a small but meaningful design choice for agent tooling: separating the discovery problem from the selection problem, and giving each its own budget. Whether that improves real workflows depends on factors the post leaves untested, including how often users type exact skill references and how models behave when instructions arrive pre-loaded versus fetched. Those questions remain open in the supplied material.

## Key points

- The post says AIClaw 3.12.13 appends an explicitly selected $skill-name's instructions to the outgoing request before the model's first response or tool choice.
- The stored user message is described as keeping its original text, with the selection added during request assembly in memory.
- The catalog is described as budgeted at up to 2,000 estimated tokens, reduced to 2 percent of the configured context window when smaller, with descriptions shortened and entries possibly omitted.
- Selected excerpts are capped at 8 KiB per skill and 32 KiB total, with truncated excerpts directing the model to load_skill for detail.
- The author states kernel tests cover request contents only and do not measure live-model instruction following, latency or provider token usage.

## Practical implications — editorial interpretation

Editorial interpretation: teams that rely on a specific skill for a first-turn task may find an explicit $skill-name reference a more predictable trigger than catalog discovery, but they should budget for the 8 KiB per-skill and 32 KiB total excerpt caps, since truncated instructions fall back to a load_skill call.

## Limitations and unknowns

This is a single community post describing a tagged release; the version, budgets and behavior are the author's claims and were not independently verified. The post explicitly says tests cover what the kernel sends, not live-model instruction following, latency or provider token usage. Pricing, broader availability and cross-provider behavior are not addressed.

## Sources

- [1] dev.to: How AIClaw 3.12.13 Loads Selected Skills Before the First Model Request
  https://dev.to/chowyu12/how-aiclaw-31213-loads-selected-skills-before-the-first-model-request-4ee0
  Retrieved: 2026-11-22T11:17:38.710Z

## Claim references

- AIClaw 3.12.13 is described as appending explicitly selected skill instructions to the outgoing request before the model's first response or tool choice. [source 1]
- The kernel is said to match complete $skill-name references against mounted skills and add the selected text to the request in memory while the stored user message keeps its original text. [source 1]
- The skill catalog is described as using an estimated budget of up to 2,000 tokens, reduced to 2 percent of the configured context window when that is smaller. [source 1]
- Selected skill text is described as limited to 8 KiB per excerpt and 32 KiB across selected blocks, with shortened excerpts directing the model to load_skill. [source 1]
- The author states kernel regression tests cover request contents but do not measure live-model instruction following, latency or provider token usage. [source 1]
