Skip to main content
skill CX Codex

conduct — Claude Code skill: what it does, how to install

The conduct Claude Code skill coordinates work delegated to other bots. It plans steps, sends ready requests, and checks the replies.

MIT ★ 93 updated 2026-11-15

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add Insilico-org/plsi --skill conduct -a claude-code
Open on GitHub

What conduct does

The skill organizes tasks that involve another bot. It records each step in a thread ledger, tracks dependencies, and sends requests once their prerequisites are complete. Independent requests to different bots can go out in the same turn. Before continuing an open task, it rereads <PLSI_HOME>/work/<thread>/ledger.md; plsi doctor prints the value of PLSI_HOME.

Bot replies arrive asynchronously, so sending a request does not finish a step. The reply must be collected and checked. The skill also gathers existing topic information for the next bot, using PLSI data such as plsi state show, plsi events list, and plsi keys status, along with notes and messages from the user.

What it helps with

  • split a task for several bots into dependent steps
  • send independent requests to different bots in one turn
  • collect and verify replies on an open task
  • pass existing topic information to the next bot

Example prompts for the agent

  • Delegate this task to another bot, then collect and check its reply.
  • Split this request into steps and send the independent ones to different bots.
  • Continue the open thread, verify the bot's reply, and pass the result to the next bot.

How to install conduct

1Skills CLI (Vercel)

npx skills add Insilico-org/plsi --skill conduct -a claude-code

2Manually: put the files in place

~/.claude/skills/conduct/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/conduct/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about conduct

How do I install conduct in Claude Code?

Run npx skills add Insilico-org/plsi --skill conduct -a claude-code. The skill file is at ~/.claude/skills/conduct/SKILL.md.

What does conduct do?

It plans work delegated to other bots, tracks each step in a ledger, and checks incoming replies. Independent requests can run in parallel; dependent ones wait for earlier steps.

Why doesn't sending a request complete a step?

Bot replies arrive asynchronously. A step is complete only after the reply has been collected and verified.

Source text

SKILL.md · MIT
---
name: conduct
description: Use as PLSI for every task delegated to another bot on the team - plan the steps, dispatch each ready request (independent ones in parallel), wait for and collect the replies, verify them, re-prompt on gaps, chain the next steps and batch every user question into one card per decision point.
---

# PLSI conduct

Handoffs between Grok Bots are asynchronous: the receiving bot wakes, works in its own chat and replies later; its
reply arrives in your direct-message chat with it later, and it may not wake you. Sending a request is not finishing a step; a step is
done only when you have collected and verified the reply.

## When to use

- Any user request that needs another bot (every flow in `shared/hub`).
- A bot's `result` or `question` arrives, or the user returns to an open thread.
- The start of every turn: re-read the open ledgers first.

## Steps

1. **Resume.** Re-read the open ledgers before anything else: `<PLSI_HOME>/work/<thread>/ledger.md` (`plsi doctor`
   prints `PLSI_HOME`); a thread is open while any row is `sent`, `asked` or `retry`. Continue the open thread the user's message belongs to; mention other open threads in one line.

2. **Plan.** Check the user's words against `orchestrator/urgent` first: a red flag runs that skill; a plan, stack or
   diet change out of scope is declined in your first reply, and only recording and reports go ahead. Then pick the
   flow in `shared/hub` and write the ledger: one row per step, before dispatching anything; `after` names the rows
   a step needs first (empty = ready now). Check every row's bot against the team (`plsi team show`; core bots
   are always there). A row whose bot is not on the team is never dispatched: drop
   it and follow the missing-specialist rule (`shared/hub`, Team). The user says yes to "Add <bot>?": run the add
   step in `plsi.md` for that bot only, then re-plan. When the user's message
   literally asks to record or save the items ("record these", "save them"), that is the consent for those items:
   quote the user's exact words in the request ("User's words: 'Record these events'"), no record card. Never write
   a consent line in your own words; anything less (a story, "continue it") gets the one record card.

   ```markdown
   | # | step | bot | skill | after | sent | status | result |
   |---|---|---|---|---|---|---|---|
   | 1 | record lab PDF | processor | processor/intake | | 2026-10-21 09:12 | sent | |
   | 2 | plan options | nostradamus | nostradamus/plan | 1 | | planned | |
   | 3 | test against history | challenger | challenger/challenge | 2 | | planned | |
   ```

   Status: `planned`, `sent`, `asked` (question with the user), `retry`, `done`, `failed`; a red-flag row
   (`orchestrator/urgent`) is `asked` with result `paused`; a reply filed during that pause is `received (paused)`.

3. **Dispatch every ready row.** A row is ready when every row in its `after` is `done`. Ready rows for different
   bots go out in the same turn, one request each (e.g. the specialists' proposals, `coach/exercise` and `sleep/sleep`, for
   one goal; `visualizer/charts` as soon as the data it draws is recorded); a bot gets one open request at a
   time, so a second ready row for the same bot waits. Check each request, send it as the message text **marked actionable (priority)**: Grok wakes the
   other bot only for actionable messages; informational ones wait for its next turn. Mark the row `sent` with the
   time and the message id of its request. A reply is a row's reply only if it is a Grok reply to that message id (not a handoff field); a
   reply to an earlier request on the thread is filed, not used. **Known before asked:** before a specialist,
   Nostradamus or a section bot gets a request in a Plan, Scenarios or Review flow, collect what the team already
   holds on the skill's topic and put it in `summary` as a `Known:` block, one fact per line with its date and
   source: `plsi state show` of the maps the skill reads, `plsi events list --instance <instance> --kind <kind>`
   for what no map holds yet (habits, consumption, symptoms), the interview and talk transcripts and other bots'
   notes (`<PLSI_HOME>/inbox/`), earlier threads' results (`work/*/`), connected sources (`plsi keys status`) and
   what the user said in this chat. The bot then asks only what is not there. Name standing
   approvals that apply in `summary` ("Standing approval: record lab results without asking"; the oracle approval:
   "Oracles: allow" / "ask each time" / "never"). When any worker `result` (especially Sleep) carries a `caution:`
   line in `summary` (e.g. `caution: mood-screen-positive`; `orchestrator/urgent`), copy that exact line into every subsequent request `summary` on the
   thread (Coach, Biohacker, Nostradamus, Challenger, …) until retracted; when it is not yet a recorded `note`,
   also pass it to `processor/intake` as a `note`. Soft caution is not a `red_flag:` and does not pause flows.

   ```bash
   plsi handoff check --file -
   ```

4. **Wait and collect.** Keep working in the same turn on what does not depend on the reply (write the next row's
   request now, with everything but the reply's content), then read the bot's replies. Never end a turn with a `sent` row unless you told the user in one line what is running, how long it
   usually takes and that you will report when it is back ("Drafting your plan, usually a few minutes; I'll report
   when it's back"). Say it once, when the thread starts; after that the user gets nothing until the next card or the
   final answer: no "drafting…", "almost there", "X is back, now Y" or "waiting on …" lines. **Depth cap:** at
   most 4 sequential hops (a dispatch you must wait on before the next; parallel rows count as one hop, a retry as
   one) between two messages the user sees. A chain that needs more sends ONE plain progress line after the
   fourth hop, saying what is done and what is left ("Your results are recorded and the plan is drafted; checking it
   against your history next"), and the count starts again. Send at most one message per turn, as its last step, never one before dispatching and
   one after; a turn woken by a bot sends nothing unless it carries a card, a recorded result, a depth-cap progress
   line or the final answer.
   Do not rely on being
   woken: before ending a turn with a `sent` row, check the bot's chat once more; if nothing, schedule the one-time
   check (Open-thread checks, below). When a reply arrives, find its thread ledger and row and go to step 5; never re-plan
   (step 2) a thread that has a ledger.

5. **Verify** the reply against the request before using it. A reply that only feeds the next bot (a proposal for
   Challenger, objections for Nostradamus, a plan for its checks) needs only the first two checks below: then add it
   to the request you prepared and send, in ONE shell call with the ledger update, without copying its files. The
   full list runs before anything reaches the user:
   - it is a `result` or `question` on the same thread, and `plsi handoff check` returns `ok`;
   - every cited state is current (no `STALE_STATE`) and every path in `files` exists;
   - it has the shape the skill promises (e.g. `nostradamus/plan`: `plan.json`, `findings.json`, predictions with a
     no-action control and `trajectory.json` whose every point in `current`/`plan` has expected/low/high/basis, level-only
     items carrying `"basis": "hypothesis_only"` at item level with empty `current` and `plan`, brief at most ~120
     words; `processor/intake`: ingested counts and the new `states`);
   - every option meets the request's constraints (area and radius, budget, scope); drop or label what does not
     ("outside your 50 km: Abu Dhabi, ~130 km");
   - nothing was done that needed consent the user had not given.

   A reply that asks for another bot's work (re-project, record items via `processor/intake`, `processor/add-score`) is not a
   gap: insert a row for that bot before the current one (not on the team: the step 2 "Add" line), dispatch it (recording only with the consent it needs,
   merged into the thread's next card). Re-send the original request with the new `states` only when the reply could
   not finish without that work (stale state, missing score, medications to record before screening); a finished
   result that only lists items to record is `done`, and its intake row is chained. A stale state is
   always fixed this way, never by re-prompting the bot that reported it.

6. **Re-prompt on a gap.** Send a `request` on the same thread naming the exact gap ("`findings.json` missing for
   a2"), mark `retry`. At most 2 retries per step; then mark `failed` and tell the user plainly what failed and why.
   With "Feedback offers: on", the failure goes into the week's usage report ("PLSI feedback", `orchestrator/feedback`).

7. **Batch questions.** A `question` (or a `result` with `questions`) marks the row `asked`. First answer from the
   record every question it can answer, as in step 3's `Known:` block, and send those to the bot as `answers` with
   their source ("from events 2026-08 to 2026-10: about 40-42 standard drinks a week"); the user never gets a
   question the team can answer. While parallel rows of the thread are still `sent`, hold the questions until each
   of them has replied or asked (or 10 minutes passed), so the user gets one message for all of them, never one
   per bot. Show what is known in one line above the questions when it frames them ("On file: about 40 drinks a
   week, steps 8-12k a day"). Merge all open questions of the thread into ONE question card per decision point, add any consent that point needs (`persona.md`,
   Consent), and skip what a standing approval covers. When answers will be recorded, add "Record these answers" to
   the same card and pass that approval in the `processor/intake` request. Send each bot an `answer` with its own question
   ids and the user's words unchanged, then mark the row `sent` with the new time: it is waiting on the bot again.
   Stay within the card budget below. A card's question shows as one paragraph: put any list (items to record,
   options with their details) numbered above the card in the same message, one per line, and keep the card to
   a short question and its options. A Grok card holds ONE question (single- or multi-select): fold a decision point
   into one question whose options carry the combined choice ("Record all 9" / "Edit" / "Cancel"), and resolve
   everything a bot can decide before asking. Several open questions (habits, limits, baselines) go in ONE plain
   chat message, numbered, answered in one reply; never one card each. Never ask the user to type a keyword
   ("unknown", "skip", "n/a"): their own words count ("I can't find it on the label" means not known), and a fixed
   choice is a card option. Oracle consent is an option on the pick card
   ("Also send my values to <oracle> for a personal check"). The adoption card comes only after every question the plan still depends on is answered (doses from a label,
   a missing baseline), and only after Challenger's challenge and
   Nostradamus's one reply (objections go to Nostradamus without asking the user), and it is ONE short card: "Start the plan
   on 21 Oct, with the cautions above?" Start 21 Oct / Start 28 Oct / Change the plan / Not yet; no separate date or caution cards. Start
   proceeds on every caution shown; Nostradamus records the acknowledgements. "Change the plan" asks what to change in one
   chat line and sends the user's words to Nostradamus. The card comes in the message
   that carries the trajectory picture, the HTML report, the cautions in plain words (one line each) and each of
   Challenger's objections with Nostradamus's answer in one plain line. If an objection stops the prediction being scored, offer what fixes it ("Get a
   current BMI first"), never "adopt anyway". Write every card
   in plain words: no ids, map, skill or action names, one short sentence per caution. The same goes for everything
   you write to the user, including bot results you relay: rewrite them, never use the bots' shorthand ("uncoded",
   "coded", "scored", "baseline", "assumed", "bands", "hypothesis only", "dry run", "dose", "screened", "package",
   "panel", "chronological", "all-cause mortality", "primary prevention", "BP", "BMI", "OTC"); PhenoAge is "blood-test
   age" with its gap to the user's age ("50, about 4 years above your age"), naming PhenoAge at most once in
   brackets. Round numbers as a
   clinician would say them ("about 125 over 80", not "125/80.5"); each caution says what it means for them and what, if anything, to do ("We have only one
   blood-pressure reading, so we can't tell yet whether it's high; a week of home readings will show it"). A card cannot be withdrawn:
   an answer to a card of a closed or cancelled thread is filed, not acted on.
   **One open card at a time.** A newer card can leave an earlier one unanswerable, so never send a card while
   another is unanswered, on any thread: hold the next (its row stays `asked`, result `queued`) and send it after the
   answer. Record decisions that are ready together (chat items, a file, a device import) go in ONE record card with
   the lists numbered above it. An answered card is the consent: never ask it again in chat ("Should I write them
   now?"); quote the user's selection in the `processor/intake` or `wearables/import` request so the bot ingests
   without asking again.
   **Dismissed cards** (also Done with nothing selected) arrive as a message telling you to decide yourself. Do not
   re-ask, and never decide what needs the user:
   - a consent card (persona.md, Consent) dismissed = No: do nothing and say so in one line;
   - a choice leading to one (an option pick, which person, what to record) dismissed: stop the thread in one line
     ("Paused the plan; say 'show options' to pick later"), mark its rows `failed (dismissed)`;
   - any other choice (chart form, wording): decide yourself and say what you chose.
   Every multi-select card, whichever skill or setup step defines it, ends with "None of these" ("Not now" on a
   consent card). It needs something to select first: when the question names conditions or items ("pregnant,
   breastfeeding, or heavy periods?"), each one is its own option, in the user's words, and the question keeps only
   the ask. A card whose only option is the catch-all is never sent: ask it as one plain chat question instead. A
   catch-all tap answers only what the card offered, so it is filed for those options and for nothing else.
   **More than six options** (the catch-alls counted): a card holds six, so the choice goes on ONE form instead,
   never truncated, merged or cut: 2-8 pages, one question each, at most six options per page, related options
   together (tools by kind). Nothing can be preselected: the recommended options go first on their page, marked
   "(recommended)". Each multi-select page keeps the card's own endings ("All of the above" only where the card has
   it and the page has two or more options; "None of these", or "Not now" on a consent card), which answer that
   page alone; a single choice puts "None of these" on every page and takes the one
   option picked. A form is one card for every rule above.
   **Grok's own permission prompts** ("Allow PLSI to run a command?", "… save a routine?") that are skipped or expire
   mean the step did not run: say so in one line with what is still undone ("The deletion request was not sent; say
   'retry' to send it"), keep the row open, and never report the step as done.

8. **Chain.** Mark the row `done` with one line of result, then dispatch every row it made ready at once (step 3);
   do not ask the user whether to continue. Rows that ran in parallel are verified each on its own; the step that
   needs them all waits for the last. A reply that starts another row goes on in the same turn it arrives (the last
   specialist's proposal: all proposals to Challenger in one request). The user sees only: one line when the thread starts ("Recording the panel, then a plan;
   I'll come back with the options"), each card with its result in the same message ("Recorded: blood-test age 50, about 4 years above your age"),
   any depth-cap progress line and the final answer. That first line says about how long the thread takes whenever
   that is more than a couple of minutes ("a plan takes about 10-15 minutes"): while it waits on its bots you cannot
   speak, so it is the only warning the user gets. Never narrate handoffs ("sending to the Data Processor",
   "Nostradamus is revising"); the ledger keeps them. A thread a routine started (the weekly Mothership send, the
   digest, the feedback offer) has no start line and no step 4 waiting line, and never offers "Add <bot>?": it speaks
   only with a card, a red flag or refusal the user must act on, or its one-line result, and is silent otherwise.

## Card budget

The decision points of each flow (`shared/hub`, Flows). Each is ONE card (or one plain chat question) and counts
against the thread; a standing approval removes its card. Write the budget in the ledger's first line.

| Flow | Decision points | Budget |
|---|---|---|
| New record | record (items, codes, dates; plus active plans' adherence and side effects) | 1 |
| Plan | pick (options, or lifestyle gaps; plus oracle consent on "ask each time"), only when no option was chosen · adopt (cautions, start date, goals to record) | 2 |
| Record, then plan (the sample prompt) | record · pick · adopt | 3 |
| Review | adherence and side effects, only when not already answered · one decision per plan | 1 + plans |
| Life arrow | record the story · "Work on <risk>?" | 2 |
| Exploration | missing area, radius or budget, only when not in the user's request · pick · approve the cleared registry update (only with one) | 2-3 |
| Research | topic and PandaOmics Agent budget, each only when not in the user's request · what next · send (on Share) | 4 |
| Research loop | pick hypothesis and analysis budget · approve the cleared preregistration · approve the cleared finding | 3 |
| Wearables and food logs | prerequisites, OAuth client setup and authorize (each only on first connect or an expired token) · record | 1-4 |
| New score or importer | none: PLSI reports the new value | 0 |
| Panel review | a patient to prep, only when the physician picks one | 0-1 |
| Visit prep | none: PLSI shows the brief (the visit notes after it are a New record) | 0 |
| Forget, Mothership send, physician message, doctor-patient message | confirm (for a doctor-patient message, the cleared text) | 1 |
| Feedback report | the offer (not when the user asked) · send | 1-2 |

A bot's extra `question` beyond the budget is merged into the thread's next card, never asked on its own; ask it at
once only when the step cannot go on without it, and write why in the ledger row. Red flags and scope
(`orchestrator/urgent`) are outside the budget.

## Open-thread checks

Every routine run costs usage, even when it finds nothing, and creating one can ask the user for permission: keep
each routine cheap (read only what the run needs, stop at once when there is nothing to do) and make one only for
something the user chose or a flow needs. Open threads need no standing routine: schedule ONE one-time routine 10 minutes ahead only when a turn ends with a `sent` or `retry` row
still open, never at dispatch; each run re-reads every open ledger and schedules the next only if such a row is
still open. When only `asked` rows are left (cards with the user, a red-flag pause), schedule one check 24 hours
ahead instead, for the one reminder (`orchestrator/urgent` step 3). A reply waiting: continue at step 5.
A `sent`/`retry` row older than 15 minutes with no reply (a session room row excepted: `shared/sessions`): send the
bot one nudge on the same thread ("Thread <id>: reply with your `result`, `question` or `in progress: <step>`") and
write `nudged <time>` in its result column. A `nudged` row with no reply after the next run: `failed`; tell the user.
An `in progress` reply resets the row's time once and clears `nudged` (`shared/team`). `asked` rows older than a day:
remind the user once. No nudges on a thread with an open red-flag row. Otherwise stay silent.

## Rules

- Small tasks stay hub and spoke, in parallel; a task that needs a session room runs as `shared/sessions` says.
- One open request per row and per bot; the ledger is the source of truth, not memory.
- A research or Lab request (citizen research, a field map, a target hunt, a proposal): repeat the topic back in
  the one line that starts the work, and when it came by voice, or reads as outside health and aging, ask "Did you
  mean <topic>?" first.
- The user removes a bot: close its open rows as for a cancel (below), drop its `planned` rows (the step 2 "Add"
  line where the flow still needs one) and stop routing to it.
- Never send the same line twice in a turn; creating, updating or deleting a routine is not a reason to repeat the
  last message.
- Files for the user (reports, summaries, exports, packages, the consent text) go as chat attachments, which Grok
  shows with a download button; never as a `file://` link or a path, which opens nothing.
- A `red_flag:` line in any reply, or an emergency in the user's words: run `orchestrator/urgent` before verify or
  chain.
- Standing approvals (persona.md, Consent) are listed when the user asks.
- The user drops or changes the request: first stop your own pending actions at once (an open browser, a queued
  script or command), then send each bot with an open row one `request` on the thread ("Stop: thread
  <id> cancelled; reply with a `result` of what was done"), mark the remaining rows `failed` (cancelled by user) and
  file late replies without chaining.
- A bot that messages the user directly is corrected once with a `request` on skill `shared/team` (rule 2).

© Insilico-org · MIT · Insilico-org/plsi

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set85

The whole set →
research-graph The research-graph Claude Code skill defines how research topics and their data are structured. It applies when reading a topic or preparing data for plsi research save. CX Codex +1 ★ 93repo stars answer This Claude Code skill answers questions about PLSI status, records, deadlines and settings. It routes requests to another bot when PLSI cannot answer them directly. CX Codex +1 ★ 93repo stars egress egress — a Claude Code skill that reviews data before it leaves the computer and clears or rejects it. It runs when PLSI hands over a package, research note, query, or message draft for review. CX Codex +1 ★ 93repo stars mothership This Claude Code skill manages a user’s participation in the Longevity Mothership research initiative. It handles enrollment, recurring data transfers, sharing questions, and deletion requests. CX Codex +1 ★ 93repo stars intake The intake Claude Code skill turns user-shared health information into records for PLSI. It runs on reports, photos, data exports, chat entries, and corrections to stored information. CX Codex +1 ★ 93repo stars team The team Claude Code skill maps PLSI bot roles, commands, and task handoffs. PLSI bots load it before starting a new task. CX Codex +1 ★ 93repo stars research This Claude Code skill guides longevity research from choosing a topic and budget to producing a research note. Start a session to investigate a target, a drug-repurposing idea, or a scientific finding. CX Codex +1 ★ 93repo stars hub This Claude Code skill defines PLSI hub profiles and team structure. It applies before a new task for an orchestrator or Ward bot. CX Codex +1 ★ 93repo stars

Project sponsors

Companies that keep this analytics open