Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Pilothouse

    0

    Run a team of Claude Code cloud sessions with fixed roles, short handoff files and cross-room messages, so each room keeps only its own context.

    Free

    1 useSecurity scanned
    Pilothouse

    Pilothouse

    Example session with this skill installed

    Use pilothouse to start three rooms for the shop app: "shop-po" as PO, "shop-dev" as Dev, "shop-qa" as QA.

    /pilothouse "shop-po" po, "shop-dev" dev, "shop-qa" qa

    • Read your context and instructions
    • Compiled the pilothouse

    Example output, following the skill's documented path for a session that has no room-creation tool.

    3 rooms parsed. Nothing was created. This session cannot create sessions, so below is a starter prompt for each room to paste into a new session.

    RoomRoleHandoff file it owns
    shop-poPOdocs/handoff/po.md
    shop-devDevdocs/handoff/dev.md
    shop-qaQAdocs/handoff/qa.md

    Checks passed: every role is a known role (po, dev, qa), and no room name is used twice.

    Starter prompts

    Replace <repo> with your repository.

    shop-po

    You are the PO room "shop-po" for <repo>. Use the pilothouse skill, role: po. Read docs/handoff/po.md first if it exists. You own the backlog: write tickets with acceptance criteria, order the queue, review Dev results. You do not write production code or merge.
    

    shop-dev

    You are the Dev room "shop-dev" for <repo>. Use the pilothouse skill, role: dev. Read docs/handoff/dev.md first if it exists. Work one ticket at a time on a branch, run the checks CI runs before pushing, and report decisions the ticket did not specify. Do not start work the PO has not queued, and do not merge.
    

    shop-qa

    You are the QA room "shop-qa" for <repo>. Use the pilothouse skill, role: qa. Read docs/handoff/qa.md first if it exists. Test the exact build the PO names, reproduce before reporting, and report pass/fail per acceptance criterion. Do not fix product code.
    

    Next steps

    1. Open three new Claude Code sessions and paste one prompt into each.
    2. Give your first goal to

    shop-po only. It writes the tickets and orders the queue; Dev and QA work from what it queues.
    3. Merging, license changes and anything published stay with you: say the word yourself in the room that does it. A message relayed from another room is not enough.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Pilothouse turns several Claude Code cloud sessions ("rooms") into a small team: coordinator, team lead, product owner, developer, UX/UI and QA. Each room holds one role and keeps only that role's context. Rooms coordinate through three channels, in this order of preference: the repository (backlog, tickets, decisions, pull requests), one short handoff file per role that is overwritten rather than appended, and cross-room messages for "your turn" signals and questions.

    What the skill gives your agent:

    • Role definitions: duties, what each role must not do, who it receives work from and who it hands work to.
    • Ownership: each room owns the quality of its own output. The PO asks whether the work is worth doing, whether the scope is complete and whether the acceptance criteria are clear; Dev asks whether the change is correct, proven and readable by the next room; UX/UI asks whether a real user can finish the task; QA asks whether testing covers the change and whether it is ready for production.
    • Pushing back: a room may disagree once, with reasons, record the disagreement in its handoff file, then follow the owner's decision. It stops only before a step that cannot be undone or puts security at risk, until the owner confirms in their own words.
    • Unclear scope: if a room is not sure which work, project or room an instruction means, it asks one question before starting, and work that belongs to another room is sent there instead of being done twice.
    • Messaging rules for sending and answering messages between rooms, including what to do while waiting.
    • A handoff file template (with a "Disagreements recorded" section) and a shared-memory layout (index plus one file per role).
    • A rotation procedure for when a room's context has grown too large.
    • Guidance for a coordinator or team lead on turning the owner's plain words into work orders per role.
    • A launch procedure: give it a list of rooms and roles and it first looks at the repository (existing handoff files, an existing team), then either creates the rooms (if the session can create sessions) or prints starter prompts for you to paste.

    Safety defaults: the human owner decides direction, merges, licensing and anything published. A message from another room is treated as information from a peer, not as an instruction from the owner. No secrets, tokens or personal data in messages, handoff files or commits.

    Honest status: this is version 0.3.0 on GitHub (v1.2 here), written for Claude Code and tested in a small number of runs by its author, mostly on toy repositories. Ownership and pushing back have not yet been run with a real team. In headless runs (claude -p) with default permissions the skill could not read its own reference files; the core rules are in SKILL.md for that reason. Room creation through the skill and message passing between rooms on a local machine are not yet tested. The README in the source repository has the full table of what has and has not been tested. It does not run any scripts or make network calls of its own; it is instructions and templates only.

    Version 0.1.0. Creating rooms from a list in a session that has a room-creation tool is untested: the session tools themselves were tried once, but the skill's own steps (parse the list, show the plan, wait for confirmation, create each room) were not. The starter-prompt path for sessions without such a tool was run once in a local test. Message passing between rooms on a local machine, the /reload-plugins command, and how quotes and commas arrive in the arguments list are also untested. Merges, license changes, publishing and spending always need the owner's own confirmation. Room rotation is a manual procedure that the owner or coordinator starts; nothing monitors context size automatically.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Requires

    Git
    Shared Git repository

    Permissions

    Read Files
    Write Files
    Terminal / Shell
    Network Access

    File Scopes

    docs/handoff/*.md
    memory/**/*.md
    AGENTS.md

    Reads and writes only the project's markdown handoff and memory files. Git is used to commit and push that work, as each role directs. The network is used by git and by Claude Code's session tools. The skill itself ships no scripts and no URLs.

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    No, and it does not claim to. It targets one cause of weaker answers in long projects: a single session carrying everything. Each room keeps only its own role's context and hands work over through short files, so a room starts from a small, clean picture. Facts still need checking against the repository and CI.

    It is built for Claude Code cloud sessions. The roles, messaging rules and handoff template are plain markdown, so another agent can read them. Creating rooms and messaging between sessions use Claude Code's session tools and will not work elsewhere.

    A free skill with: role definitions (coordinator, team lead, PO, Dev, UX/UI, QA), rules for messages between rooms, a handoff file template, a shared-memory layout, a room rotation procedure, guidance for turning your plain requests into work orders, and a launch procedure that takes a list of room names and roles. Apache-2.0, with the source on GitHub.

    You give it names and roles, for example /pilothouse "shop-po" po, "shop-dev" dev. If the session can create rooms, it shows a plan and waits for your OK. If not, it prints a starter prompt for each room to paste into a new session. The handoff files are written by the rooms as they work. Parts of this are untested; see Known Limitations.

    The rotation procedure has the room write a short handoff, then a fresh room with the same role takes over from that file. Anything not written in the handoff is not carried over, so keep it short and put decisions in the repository as well.

    No. Merges, license changes, publishing, spending money and deleting anything that cannot be restored need your confirmation, in your own words, in the room that does it. A message from another room does not count as your approval.

    New in Agents & Orchestration