Sculptured docs

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

  1. Open the agent
    Select the agent on the Design board. Its panel has a Skills section.
  2. Add a skill
    Choose 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.
  3. Or load one
    Choose 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.
  4. Or take one from a catalog
    Choose Add from a catalog, then Anthropic or Google, or Another GitHub repository and its address (any repository of SKILL.md folders, 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

AgentHow it gets its skills
Claude CodeNatively. 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.
CodexIts 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:

KindWhat the agent getsWhere it comes from
MCP server on the computer (mcp)Its tools, next to Sculptured'sA program on the agent's computer, such as Kindex's kin-mcp
Remote MCP server (mcp-remote)Its tools, next to Sculptured'sA 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 ownThe manifest itself; nothing runs
Claude plugin (claude-plugin)The plugin's skills, hooks and servers, for that agent onlyA plugin installed on the agent's computer with claude plugin install
Tool hook (tool-hook)A check on every tool call, such as Signet-EvalA program on the agent's computer

Claude plugins and tool hooks work for Claude Code agents only; the others work for Codex agents too.

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"
}
FieldMeaning
idLowercase letters, digits and hyphens; not a built-in one's id.
kindmcp, mcp-remote, skills, claude-plugin or tool-hook (see the table above).
program, argsmcp 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, headersmcp-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}.
skillsskills: 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.
pluginclaude-plugin: the plugin as name@marketplace, as claude plugin install takes it. Set claude_only.
briefingWhat agents given it are told.
installHow to set it up on a computer, shown when something is missing. Not needed for skills.
requiresOther components it needs, by id.
homepage, claude_only, description, nameAs 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.

  1. Install it on the agent's computer
    Run pip install 'kindex[mcp]' (or uv tool install 'kindex[mcp]') on the computer that runs the agent.
  2. Turn it on for the agent
    In 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.

  1. Install it on the agent's computer
    Run cargo install signet-eval there.
  2. Turn it on for the agent
    In 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.