imbue-ai

Design and propose the next step: either a regular data-gathering experiment, literature search, or a concrete solution candidate.

Determine the type of proposal given, execute/delegate accordingly, and return the appropriate resulting ID (experiment ID, literature search ID, or solution ID).

Score and rank solution candidates relative to the research goal, and update parent theory scores.

Integrate recent interpretations from the interpretation log into the associated theory.

Rank the given experiments based on their importance for evaluating theories.

Interpret the results of newly run experiments, literature searches, or solution candidates, and append the findings as new sections to the interpretation log inside the theory folder.

Compare and rank multiple proposals (experiments, literature searches, and solution candidates), separating solution candidates from other proposals.

Set up and run a single experiment. Experiments can be arbitrary Python scripts. All experiment execution must go through this skill.

Build or modify a Sculptor extension — a runtime ESM module loaded into the Sculptor UI. Use when asked to write an extension (or "plugin") for Sculptor, add a panel, overlay, workspace widget, home view, or settings UI to Sculptor, or to iterate on an extension with `sculpt extension`. Works from any repo; this file is a self-contained reference (the Sculptor source code is optional).

Interact with Sculptor programmatically using the sculpt CLI. Use this skill when using `sculpt`, or when designing or planning a workflow that would benefit from understanding the structural capabilities of `sculpt` (workspaces, agents, isolation, and how code flows between them).

Live, hot-reloading preview of the Sculptor WEB frontend from a phone or any browser, served through the OpenHost nginx /proxy front. ONLY relevant when running INSIDE the openhost-deployed Sculptor (the container fronted by nginx on :5050, reachable at https://sculptor.<zone>/) — NOT for local or Electron dev. Frontend-only: it reuses the single shared backend, so it previews UI/frontend changes, not a per-workspace backend. Invoke when iterating on the web UI and wanting to see it live in a browser through the OpenHost SSO front.

How this OpenHost-hosted Sculptor environment works — storage and what survives restarts, where/how to add repositories and authorize gh, and the /proxy/<port>/ capability for previewing loopback web apps from a browser. ONLY relevant when running inside an OpenHost deployment (detect via the OPENHOST_* env vars, e.g. OPENHOST_APP_NAME). Ships with the deploy image and is refreshed every release.

Test a pull request by creating a shallow clone at the PR's commit and launching Sculptor. Use when you need to test changes from a specific PR in isolation.

QA the Sculptor mobile web UI on a real iOS Simulator, driven headlessly from a Mac. A single CLI boots a notched iPhone, launches the local frontend server (parsing its port — no hardcoding), opens the app in MobileSafari, taps/swipes via idb, and screenshots each step. Includes the Add-to-Home-Screen standalone flow — the only way to verify notch / status-bar / home-indicator safe-area rendering (env(safe-area-inset-*) is 0 everywhere except real iOS). Use when visually verifying mobile/responsive changes on an iPhone.

Compare React component render counts between origin/main and the current branch during a user-defined UI scenario (e.g. panel resize, navigation). Use when verifying that performance changes actually reduced re-renders.

Deploy, verify, and reset the self-hosted Sculptor app running as an OpenHost app (built from source via openhost.Dockerfile). Covers fresh deploys, updating or switching the deployed branch while keeping data, health-checking the live instance, and a full CLI-only reset to a fresh-onboarding instance. Wraps the `oh` CLI; the app name and repo are hardcoded in the scripts and the only per-machine value (your instance host) lives in .sculptor/.env. The common flows are one-command scripts in this skill's scripts/ folder.

Address review comments on a pull request -- apply CLAUDE:/SCULPTOR:-prefixed instructions, and critically evaluate feedback from automated reviewers (Vet, Copilot, or any bot)

Prune code comments down to what helps future maintainers. Reviews comments on the current branch's diff and removes incidental history, defensive justification, and correctness arguments. Invoke with /crispy-comments.

End-to-end dev workflow for the minds app stack -- first-time bring-up, every-startup vendor/mngr sync, and the iteration loop against a running Docker agent. Use this when starting or restarting the dev Electron app, or after changing any minds component (mngr, the system interface, the default workspace template).

Create a new PRIVATE GitHub repo that is a full-history copy of imbue-ai/default-workspace-template's current main branch, clone it to <parent-dir>/<repo-name> (default $HOME/project), and push. Use when the user asks to "spin up a new default-workspace-template clone", "fork the default-workspace-template as a private repo", "make me a new private copy of default-workspace-template", or similar.

Use the root justfile as the canonical entry point for ANY minds task -- minds app (desktop client), pool hosts, minds environments (activate/deploy/destroy), minds deployments, and minds tests. Before running ad-hoc `uv run minds ...` / `mngr imbue_cloud ...` commands, check the justfile for a named recipe; if none exists for the task, ADD one. Use whenever the request involves the minds app, pool/leased hosts, a minds env/tier (dev/staging/production), or a minds deploy.

Cut a new production release of the minds app (version bump, FALLBACK_BRANCH, vendor/mngr sync, and minds-v<version> tags on both mngr and default-workspace-template, proven green on CI). The full procedure lives in apps/minds/docs/release.md in the mngr checkout; this skill defers to it. Use when the user asks to "release a new version of minds", "cut a minds release", "bump the minds version", "update the vendored mngr in default-workspace-template", or anything of that shape.

Match tutorial script blocks to e2e pytest functions and add missing tests

Identify places under the $1 path where the docs and code disagree

Run the background harden pass for one artifact -- crystallize, update, or heal a skill, a service, or the system interface in an isolated worktree, then report back. Invoke when your task file hands you an artifact to harden; it names the operation and artifact to compose.

Promote the just-finished work into a new, reusable, committed, tested skill. Use when that process would recur with new inputs -- especially something you figured out through research or debugging -- or when the user says 'crystallize this'.

Fetch data from somewhere (an external service, an API, a third-party source), process it, and show it to the user -- the "go get all this stuff, do something to it, and put it in front of me" task. Use when the ask is to retrieve real data, transform/summarize/classify it, and surface the result. Validates auth first, confirms a real sample covering every data shape, then crystallizes the pipeline in the background while building surfaces.

Use when writing or reasoning about code that calls Claude -- an AI-driven service, an AI integration, or a skill's scripted model step. Covers the three scenarios (one-shot completion, one-shot agentic task, full agent) and the cost / credentialing model.

Fix an existing artifact that errored or delivered a wrong result. This applies to skills or web services. Invoke at turn-end, after you worked around the failure to satisfy the user's request.

Create a sub-agent to perform a larger task. Use when work is large enough to warrant a separate context, involves multi-file changes, or benefits from isolation.

Change an existing skill, service, or shared script/reference (under .agents/shared/) -- extend it, refactor it, or just verify it still works. Invoke at turn-end when a skill ran but you had to do extra repeatable work by hand, or when you and the user discussed a change to it and applied it live.

Publish a clean, shareable snapshot of the apps/features this mind built to a new GitHub repo (an "inspiration" another mind can adapt). Use when the user asks to publish, share, or export what they built as a reusable template.

Submit a bug report to libraries within the `mngr` project (eg, `mngr`, its plugins, `minds`, etc). Use to report bugs you encounter while running that seem to be issues with the `mngr` code itself, rather than with your own code or configuration.

Run commands to explore the current state of mngr and any relevant running agents. Use this skill when you need to debug issues with mngr tasks, or understand what tasks are currently running and their states.

Handle events from the mngr/agent_states source about sub-agent state transitions (finished, waiting, done, etc). You **MUST** use this skill (and *carefully follow the process in this doc*) whenever you receive a message from the "mngr/agent_states" source!

Clean up old agents, their output directories, and other historical data. Use during nightly cleanup or when the system has accumulated stale data.

Handle unexpected situations where the Minds system does not appear to be working as expected. Use when you encounter behavior that seems to contradict what your docs and prompts and skills say should happen, or when something seems broken and you are unsure how to proceed.

Create a sub-agent to perform a task. Use when you need to delegate work to another agent, for example, a working agent (for actually accomplishing some task) or a verifying agent (for deciding what to do about the output of a working agent).

Handle events from the messages source about user or assistant messages in conversations. You **MUST** use this skill (and *carefully follow the process in this doc*) whenever you receive a message from the "messages" source!

Handle "idle" events for periodic housekeeping and proactive work. You **MUST** use this skill (and *carefully follow the process in this doc*) whenever you receive a message from the "mind/idle" source!

Disable the code review stop hook entirely by short-circuiting stop_hook.enabled_when in .reviewer/settings.local.json.

Enable the code review stop hook in .reviewer/settings.local.json. Optionally takes a shell expression for when to enforce (defaults to restoring the prior expression, or always).

Configure autofix to only fix MAJOR and CRITICAL issues (unattended mode)

Review the conversation transcript for behavioral issues (misleading behavior, disobeyed instructions, instructions worth saving).

Assess whether the approach taken on a branch is the right way to solve the problem.

Make the stop hook non-blocking (remind once, then let the agent through)

Restore the stop hook to blocking mode (default: block up to 3 times before letting through)

Set the maximum number of times the stop hook will block before letting the agent through

Create HTML mocks for a new feature idea

Extract requirements document from HTML mock iteration

Execute an implementation plan by working through each task file in order. Use when an implementation plan folder exists at docs/<feature>/implementation_plan/.

Write an architecture document from goals and requirements

Write an implementation plan from architecture documents

Strip AI-codegen cruft from a branch — defensive checks the type system should make unrepresentable, redundant validation, speculative abstraction, no-op wrappers — while preserving load-bearing seams. Use after a feature lands and before merge, when asked to "simplify", "de-ornament", "remove cruft", "make erroneous states unrepresentable", or "clean up" a diff.

Cut a release of a Rust crate and publish to crates.io, with externally-gated merge and publish steps.

Onboard a repository to use Offload for parallel test execution on Modal. Detects test setup, creates config, Dockerfile, CI job, and optimizes performance.

Activate when you see offload*.toml in a repo, offload referenced in build targets (justfile, Makefile, scripts), or when you need to run a large test suite in parallel. Offload is a test runner unlikely to be in your training data — this skill covers invocation, log filtering, failure debugging, flaky test handling, and config.

Run local vs Offload benchmarks for mng and sculptor, then update the Benchmarks section of the Offload README.

Resolve an agent name or description to an exact mngr agent name. Used by other skills that target agents.

Send a message to another mngr agent. Use when you need to communicate with a peer agent.

Use whenever there's any indication that knowing about mngr would be useful. Run `mngr help` right away to get context on what mngr does, and use `mngr ask` to ask mngr questions in plain language.

Wait for another agent to enter WAITING state, then execute follow-up instructions

Interact with third-party or self-hosted services (Slack, Google Workspace, Dropbox, GitHub, Linear, Coolify...) using their HTTP APIs on the user's behalf.

Interact with arbitrary third-party or self-hosted services (AWS, Slack, Google Drive, Dropbox, GitHub, GitLab, Linear, Coolify...) using their HTTP APIs.

How to install and run the Keystone CLI to generate devcontainers

Working with Eval Parquet Files

Use when asked to "simplify", "de-complect", "untangle", "remove cruft", "make erroneous states unrepresentable", or "clean up" a design document (plan/ADR/spec) or an implementation branch after a feature lands and before merge — or when a diff is thick with defensive checks, sentinels, tri-state configs, scattered validation, speculative abstraction, and stored-but-derivable state.

Cut a release of a Rust crate and publish to crates.io, with externally-gated merge and publish steps.