Skills

Skills are a capability exclusive to LoopAgent: a manual (an SOP) that the model "reads" rather than "calls." A skill consists of a SKILL.md body plus optional reference files and scripts. When needed, the model reads the body in and follows the steps inside.

What a skill is and how it gets used

One skill package = a required SKILL.md + optional text files and scripts. The whole package must not exceed 20 MB, and no single file may exceed 5 MB.
Each turn the system gives the model only a "list of available skills" — names and descriptions only, no body. Only after the model decides a skill is relevant does it read that skill's full SKILL.md body in.
Files in a skill package can only be read through the skill mechanism; they are not on any local filesystem (see the sandbox note below).
A single LoopAgent can mount at most 10 skills.

Three sources

	Agent-private skill	Organization skill	Platform skill
Visibility	Only the agent it belongs to	Reusable across agents within the org	The platform's official library, visible to all orgs
Creating	"Create Skill" inside the agent, mounted automatically	Created under "Tools › Skills"	Maintained by the platform; orgs cannot create new ones
Opening inside an agent	Editable	Becomes read-only (edit it under "Tools › Skills")	Read-only
When a body change goes live	With the agent's publish: saving only affects the Debug version; it goes live only when you publish the agent	Immediately and globally: saving takes effect for every agent that references it	Not editable

"Remove" means different things depending on the source: clicking "Remove" on an organization / platform skill = unbind only, the skill itself remains; deleting an Agent-private skill = delete the skill itself as well. To fully delete an organization skill's body, do it on the "Tools › Skills" page.

Draft, Debug, and Production

A skill body (SKILL.md) goes through the same three states as the Persona. Note that the skill editor only has a "Save" button, no "Publish" button — the publish action happens elsewhere.

State	What it is	Who can read it
Draft	The content auto-saved while you type in the editor	Only the editor themselves; no conversation (including the debug chat) can read it
Save / Debug	The official body written after clicking "Save"	The debug chat reads it immediately (saving takes effect for the Debug version)
Live / Production	The body customers actually read	External channels; when it updates depends on the skill's source (see below)

Going live works in two ways depending on the skill's source:

Agent-private skill: the body goes live with the LoopAgent's publish. Clicking Save in the editor only affects the Debug version; you must publish this LoopAgent for the last saved version to go live (same logic as the persona).
Organization / platform skill: the body is immediately global. After clicking Save, it takes effect immediately for every agent that references it (Debug + Online), with no need to publish the agent.

The most common pitfall: a draft in editing can't even be read by the debug chat. To verify a change in the debug chat, you must click "Save" first, otherwise it still reads the previously saved body.

Another pitfall: for an Agent-private skill, clicking Save alone only reaches the Debug version — customers still see the published version — so remember to go back and publish the LoopAgent to go live.

Two additional notes:

Readable right after creation: creating a skill automatically writes a minimal body (form-based creation = name + description assembled; package upload = the SKILL.md from the package read in), so the model can read it even before the first publish.
Multi-editor conflicts: if several people or tabs edit the same skill at once, saving may warn that "the skill content has been updated by someone else" — just reload and save again.

Python scripts and the execution sandbox

A skill package can carry Python scripts (putting them in a scripts/ directory is a convention, not a requirement): steps that need precise computation, format conversion, or specific libraries can be written as code for the model to run on demand.

Execution mechanism:

Scripts run in an isolated sandbox (a separate Linux environment + Python 3.11), not on your server and not on the model's local machine — naturally isolated and non-interfering.
When needed, the model drops a package script into the sandbox to run and gets the result back; files in the package can also only be read through the skill mechanism, and cannot be cat / finded with bash (the package is not on the local filesystem).

"Run test" in the editor = real sandbox execution:

Clicking "Run test" on a .py script in the skill editor is a real backend sandbox execution, not a front-end simulation; it uses the same sandbox the model uses at runtime — if it passes in the editor, it will pass at runtime too.
A script erroring out ≠ the API failing: when a script throws internally, it returns normally with its output and error stack (to aid debugging); this does not mean the execution API is down. Only a problem at the sandbox layer (such as the sandbox not being deployed in that environment) counts as an API failure.
Channel / session variables are unavailable during testing: there is no real conversation context while editing, so channel attributes (such as those related to WhatsApp / Telegram) and session attributes will be empty; they only have values at real runtime. So it is normal for these variables to be empty during testing.

The bash tool: every LoopAgent comes with a bash tool, used to drive the API calls described in the skill's docs (assembling commands per the SKILL.md instructions); but Python scripts inside a skill package run in the sandbox, not via bash.

Troubleshooting when a skill has no effect

For a skill to be read by the model, it must pass several layers in order — check them in sequence:

Whether the skill module's master switch is on;
Whether the mount entry for that skill is enabled;
Whether the skill itself is enabled;
Whether the skill body is non-empty (an empty body is discarded and the model can't read it);
Whether it has the same name as another skill (skill names are case-sensitive; among same-named skills only the first mounted one is kept).

After you change a skill's mount switch, it will appear in / disappear from the available-skills list on the next message, with no need to re-save the agent.