Skills and tools on the agent's computer
Give an agent skills it loads only when it needs them, and tools installed on its computer, such as Kindex.
A skill is a set of instructions an agent loads only when it needs them: how your project handles money, how to write a release note, which checks to run before a merge. Until the agent uses a skill, only its name and one-line description sit in the agent's context, so a skill costs almost nothing until it matters.
Give an agent a skill
- Open the agentSelect the agent on the Design board. Its panel has a Skills section.
- Add a skillChoose Add skill. A full-size window opens with three fields: Name (lowercase letters, digits and hyphens, such as
money-rules), When to use it (the description the agent sees until it loads the skill) and Instructions, in Markdown. - Or load oneChoose Load from file and pick a
SKILL.md. Its frontmatter gives the name and description; the rest becomes the instructions. Check them, then Save skill. - Or take one from a catalogChoose Add from a catalog, then Anthropic or Google, or Another GitHub repository and its address (any repository of
SKILL.mdfolders, such as an HPC centre's). Search, Preview, then Add. The skill opens in the same window to check before you Save skill.
A catalog skill is copied into the agent as it is at the catalog's newest commit, and the agent's skill list links to that exact file (from the repository); later changes to the catalog don't reach it. Only its SKILL.md text is copied: a skill that also ships scripts or reference files needs those on the agent's computer. Read a skill before you add it, since it becomes part of the agent's instructions.
Skills belong to the agent: copying the agent copies its skills, and a team file or MADL file carries them with it.
How each CLI gets them
| Agent | How it gets its skills |
|---|---|
| Claude Code | Natively. The runner writes them as a plugin in its own data folder and passes it for that session only. Nothing is written into your project. Claude loads a skill when its description applies. |
| Codex | Its briefing lists each skill's name and description, and it loads one with the read_skill tool when it applies. |
An agent on a computer whose runner predates skills runs without them, and its page says so: reinstall the runner from Computers.
Components: tools on the agent's computer
A component is something an agent is given besides Sculptured's own tools. Each is described by a small manifest rather than built into Sculptured, so anyone can write one and share it. There are five kinds:
| Kind | What the agent gets | Where it comes from |
|---|---|---|
MCP server on the computer (mcp) | Its tools, next to Sculptured's | A program on the agent's computer, such as Kindex's kin-mcp |
Remote MCP server (mcp-remote) | Its tools, next to Sculptured's | A web address, such as a hosted OpenFOAM server, with its secrets kept on the agent's computer |
Skill pack (skills) | More skills, added to the agent's own | The manifest itself; nothing runs |
Claude plugin (claude-plugin) | The plugin's skills, hooks and servers, for that agent only | A plugin installed on the agent's computer with claude plugin install |
Tool hook (tool-hook) | A check on every tool call, such as Signet-Eval | A program on the agent's computer |
Claude plugins and tool hooks work for Claude Code agents only; the others work for Codex agents too.
- Built in, as examples: Kindex memory (a knowledge graph that outlasts the team) and Signet-Eval policy checks. They need no approval.
- The team's own: in the team's Settings, under More settings, Components lists them with exactly what each runs or connects to. New component makes one from a short form: a remote MCP server, one on the computer, an installed Claude plugin, or a skill pack from an agent's skills. Add a component takes a manifest, pasted or loaded from a file, and Share to Community publishes one.
- From the MCP Registry: From the MCP Registry searches the official MCP Registry. Use fills the new-component form with what the server runs: an npm package with
npx, a PyPI package withuvx, a container image withdocker, or its web address with each secret header named as${NAME}. Check it, then Add. Anyone can list a server there, so read what it runs first; the agent's computer still asks its owner to approve it. - From Community: a shared component shows what it runs and how to set it up. Add to a team puts it in that team's Components.
- Give it to an agent: tick it in the agent's Advanced settings, where they are grouped as MCP servers, skill packs, and plugins and hooks. The agent's card then shows a chip for it. A component that needs another one (Signet needs Kindex) brings it along.
Whatever a component needs must be on the agent's computer: the program, the plugin, or the secret. If something is missing, the agent starts anyway and its page says what to install or set.
Secrets stay on the agent's computer
A remote server usually needs a key. The manifest names it as ${NAME}, and never holds the value:
"headers": { "Authorization": "Bearer ${OPENFOAM_TOKEN}" }
The computer's owner sets the value once, on that computer:
sculptured set-secret OPENFOAM_TOKEN
The runner fills it in when it starts the agent, so the team, the server and Community never see it. On your own local Sculptured, an environment variable of the same name works too.
A component is something your computer runs
On a computer connected to your account, a component that is not built in runs only after that computer's owner approves it there. The agent's page shows what it would run or connect to, and the line to approve it:
sculptured approve-component <digest>
The digest is a fingerprint of that exact manifest: if anything in it changes, it needs approving again. Secrets are not part of it, so changing a key needs no new approval. Running agents are not restarted. On your own local Sculptured, the teams are yours, so nothing extra is asked.
Writing a manifest
{
"id": "openfoam",
"name": "OpenFOAM",
"description": "Set up and run CFD cases on the HPC cluster.",
"kind": "mcp-remote",
"url": "https://foam.example.com/mcp",
"headers": { "Authorization": "Bearer ${OPENFOAM_TOKEN}" },
"briefing": "You also have the OpenFOAM tools: check the mesh before a run.",
"install": "Ask the HPC team for a token, then: sculptured set-secret OPENFOAM_TOKEN"
}
| Field | Meaning |
|---|---|
id | Lowercase letters, digits and hyphens; not a built-in one's id. |
kind | mcp, mcp-remote, skills, claude-plugin or tool-hook (see the table above). |
program, args | mcp and tool-hook: a plain program name the runner finds on its computer (no folder), and its arguments. In a tool hook, {safety_rules} becomes the path of the team's safety rules. |
url, headers | mcp-remote: the server's address (https://, or http:// for a server on the agent's own computer) and request headers. Each header names its secret as ${NAME}. |
skills | skills: the skills it adds, each with a name, description and body, as in a skill. The agent's own skill of the same name wins. |
plugin | claude-plugin: the plugin as name@marketplace, as claude plugin install takes it. Set claude_only. |
briefing | What agents given it are told. |
install | How to set it up on a computer, shown when something is missing. Not needed for skills. |
requires | Other components it needs, by id. |
homepage, claude_only, description, name | As named. |
A runner from before remote servers and plugins starts the agent without them, and its page says to update the runner.
Kindex
Kindex is a knowledge graph that lives on the agent's computer and outlasts any one team: decisions, constraints and discoveries that agents search and add to across sessions. Sculptured's own Knowledge covers one team's work; Kindex keeps knowledge for later work in the project.
- Install it on the agent's computerRun
pip install 'kindex[mcp]'(oruv tool install 'kindex[mcp]') on the computer that runs the agent. - Turn it on for the agentIn the agent's Advanced settings, tick Kindex memory. It is one of the built-in components.
At its next start the agent gets Kindex's tools next to Sculptured's, and its briefing says what Kindex is for. The runner finds kin-mcp on that computer itself; Sculptured never sends it a command to run. If Kindex is not installed there, the agent starts anyway and its page says how to install it. Kindex's own question and learning features call a model and cost usage; its search and storage do not.
Signet-Eval
Signet-Eval checks every tool call against a policy, with no model and in milliseconds. Sculptured's own safety rules use its rule format; give an agent the full tool when you also want its vault, spending limits and locked self-protection rules.
- Install it on the agent's computerRun
cargo install signet-evalthere. - Turn it on for the agentIn the agent's Advanced settings, tick Signet-Eval policy checks. Kindex comes with it.
The runner adds signet-eval as a second hook after Sculptured's guard, with the team's safety rules as its rules; its own system policy (~/.signet/policy.yaml, or its built-in one) still applies. Its built-in locked rules refuse edits until the agent has used Kindex and refuse Claude's task-list tools, which is why Kindex comes with it. Claude Code agents only: Codex runs hooks only after you trust them on each computer.