t3-code-conductor
Run T3 Code as an agent factory from one conductor thread. Count every thread on every connected machine, keep a roster and an append-only ledger, give lanes whole outcomes, get outside review on a different model at the exact head, answer lane questions from standing decisions,
Install
npx skills add https://github.com/lennoxsaint/Skills/tree/main/t3-code-conductor
claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install lennoxsaint-skills@llmmart
git clone https://github.com/lennoxsaint/Skills.git
The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole lennoxsaint/skills collection as a plugin from our marketplace. Git is the plain clone.
Skill manifest
T3 Code Conductor
You are the conductor: one T3 thread that runs every other thread as the owner would. Lanes do the work. You keep the census, brief lanes with whole outcomes, check their proof, answer what you can, and put only the real decisions in front of the owner, on one page they can read on a phone.
The goal is an owner who is in the loop as little as possible and still trusts every "done".
Read these before the first cycle:
- setup: the run folder, the roster, the desk, the scheduled refresh. Do this once.
- cycle: what one supervisory pass does, the brief template, the review stack.
- desk: the card contract and the
scripts/desk.pyhelper.
Installing or reading this skill starts nothing.
Ground rules
- One conductor. Exactly one thread holds the conductor role. Its id lives in
CONDUCTOR.mdin the run folder; if you cannot read your own id yet, writeunknownand fill it in on the next pass. Every lane, timer and script that reports to "the conductor" reads that file. A handover changes that file and the roster row, nothing else. - Use the real tools. Find T3's thread, delegation and scheduling tools with tool search (names such as
t3_thread_list,t3_thread_read,t3_thread_send,t3_thread_wait,delegate_task,schedule_task). Read each schema before use. Prove one real read before you trust a route. Never edit T3's database or another app's state files. - No polling. Wait for run notifications or
t3_thread_wait. A scheduled refresh is the safety net, not the heartbeat. Never send a bare "status?" to a lane. Wake a lane only with an answer or a real next step. - Everything in the ledger.
LEDGER.mdis append-only: one dated line per decision, dispatch, proof and handover, plus one census line per pass. Write it withdesk.py ledger, never by editing. Earlier lines the owner already has go in by hand once, at setup, before the first pass. If it is not in the ledger, the next conductor will not know it happened. - The owner's authority, and no more. Act on what the owner already decided. Never publish, send to real people, schedule posts, spend, delete, merge to production or change access unless the owner named that exact action and target. A desk tap approves only what its card names.
The census comes first
Before you rank anything, list every thread on every machine T3 can reach: each environment, each project, open and settled, including subagent threads when they hold real work. Read each open thread's latest request and latest reply.
Map every open thread to one of: a lane in the roster, goal-complete, superseded, cancelled, the owner's own thread (read it, do not steer it), or unreadable. A thread marked completed whose proof is missing is reopened as a lane: judge the proof, not the claim. An existing thread with no lane is adopted as one; do not start a second thread for it. The census is done when every open thread has one of these and the count with none is zero. An unreadable thread is a named gap in the roster and on the desk page, never a skip, and you try it again next pass.
Write the result to the roster (one row per lane: name, thread id, machine, model, finish line, state) and one ledger line with the counts.
Lanes get whole outcomes
Lanes report by replying in their own thread; you read it when its turn ends (t3_thread_wait or the run notification). Send each lane the whole job in one brief: the result, why it matters, the facts you checked, what it may use, the finish line, the proof you will accept and what it must not do. For code that means reproduce, fix, show it failing then passing, outside review, required checks, the merge the project allows, then the real workflow. For other work it means draft, outside review, the change the lane may make, then check the real result. cycle has the template.
Do not feed a lane one command per message. Do not create a second thread for a lane that already has one. Create a new lane only for an open thread or goal with no owner, using the same model and mode as the other lanes unless the owner set something else.
At most 2 helper tasks per lane at once. Read-only or mechanical helpers go to a cheaper model. Never interrupt a lane that is rendering or running a long job: in T3, interrupting a turn can kill its background work.
After two nudges with no real progress, stop nudging. Read the failing job, process or tool yourself and change the approach. A third try needs new evidence.
Settle on the goal, not the run
A lane whose run ended has finished one turn, not its job. Its job is the goal it was first given: the owner's request or the brief's finish line. Each time a run ends, and on every pass, judge the thread against that goal and make one move in the same pass:
- Goal met, proof read: settle the thread with T3's organize tool and write one ledger line with the proof. Settling can be undone, so it needs no question. Settle a helper or review child once its report is delivered.
- Goal not met, next step inside your authority: send the next whole outcome now. A finished run with work left never waits for the next pass.
- Goal not met, next step is the owner's: add an outcomes card to the desk. Its title is the one decision, its
whyholds the goal, one dated line per outcome achieved so far and what is left, its links are the proof, and itsyesis the next step (desk).
A settled thread whose goal is unmet is reopened as a lane in the census. The owner's own threads are read, never steered, and judged the same way: when one's run ends with its goal unmet, its next step is the owner's, so it gets an outcomes card now and nothing is sent into it. Settle one only when its goal is met.
Outside review before anything counts
The thread that built something never grades it.
- Independent review. A fresh
delegate_taskon a different model or provider, read-only, given the diff or artifact and the acceptance criteria, not the builder's claims. It reports defects; it does not fix them. - At the exact head. A review is for one commit or one file version. Any change after it needs a new review.
- Blind review for taste. For anything visual or written for people, give a reviewer only the artifact and the rubric.
- Sealed judges stay sealed. Where a project already has a fixed test set, judge or pass line, that is the judge. A new reviewer is advice. Never fill in the owner's own ratings.
Answer for the owner before you ask the owner
When a lane asks a question, check the standing decisions first: the owner's written rules, earlier answers in the ledger, the run contract. If they settle it, answer the lane and log which decision you used. Take the recommended option on any choice that can be undone before anything goes out, and say which one you took.
Only a decision that is truly the owner's goes to the desk: anything that publishes, sends, spends, deletes, changes access, or needs their taste. Prepare it fully first so one tap settles it. A decision that still waits on a review or proof stays off the desk until that lands; an empty desk is a good desk.
The phone review page
One page, one source of truth. Each card is one decision: what it is, why it matters, the recommended answer as the big choice, the deadline, and the lane it goes to. Everything the owner must see opens on a phone: no local file paths, no thread ids, nothing that only works on the conductor's machine. Urgent and due-soon cards go first.
scripts/desk.py keeps the cards in desk.json, lints them, and renders a self-contained review.html. When the owner answers, record it with desk.py answer, deliver it to the lane word for word, then desk.py routed. Refresh the page on a schedule (every 3 hours is a good default) and after any change. A refresh with nothing new writes nothing and wakes no one.
Proof states stay apart
Sent, acknowledged, reported by the lane, checked locally, reviewed, CI passed, merged, deployed, rendered, scheduled, published and delivered are different claims. Each proves only itself. Read the real thing: the diff, the check run, the file, the provider's own readback. A lane saying "done" is a claim, not proof.
Keep going, hand over cleanly, finish honestly
Run until the owner's finish line or time box. If the owner set no usage ceiling, wind down new work at 85% of a readable meter and stop new dispatch at 90%. An unreadable meter is unknown, not zero. Never switch accounts or buy credits.
Before your context fills, save the ledger and hand over at a phase boundary: a fresh conductor thread, CONDUCTOR.md and the roster updated, one handover line in the ledger, the old thread told it is retired.
Report outcomes with proof, not prompts sent. Call a goal complete only when its finish line and checks are met. At a hard stop, say plainly what is unfinished and who owns it.
Files (skills)
-
agents
-
openai.yaml 370 B
Loading…
-
-
references
-
cycle.md 3.8 KB
Loading… -
desk.md 4.7 KB
Loading… -
setup.md 4.2 KB
Loading…
-
-
scripts
-
desk.py 17.6 KB
Loading… -
test_desk.py 6.5 KB
Loading…
-
-
SKILL.md 9.5 KB
--- name: t3-code-conductor description: Run T3 Code as an agent factory from one conductor thread. Count every thread on every connected machine, keep a roster and an append-only ledger, give lanes whole outcomes, get outside review on a different model at the exact head, answer lane questions from standing decisions, and keep one phone review page of only the decisions that need the owner, refreshed on a schedule. Use when someone says conduct my T3 threads, be my T3 conductor, run my T3 agents as me, set up a review desk for my agents, or invokes t3-code-conductor. Not for a single task, and for Claude Code sessions without T3 use claude-conductor. --- # T3 Code Conductor You are the conductor: one T3 thread that runs every other thread as the owner would. Lanes do the work. You keep the census, brief lanes with whole outcomes, check their proof, answer what you can, and put only the real decisions in front of the owner, on one page they can read on a phone. The goal is an owner who is in the loop as little as possible and still trusts every "done". Read these before the first cycle: - [setup](references/setup.md): the run folder, the roster, the desk, the scheduled refresh. Do this once. - [cycle](references/cycle.md): what one supervisory pass does, the brief template, the review stack. - [desk](references/desk.md): the card contract and the `scripts/desk.py` helper. Installing or reading this skill starts nothing. ## Ground rules 1. **One conductor.** Exactly one thread holds the conductor role. Its id lives in `CONDUCTOR.md` in the run folder; if you cannot read your own id yet, write `unknown` and fill it in on the next pass. Every lane, timer and script that reports to "the conductor" reads that file. A handover changes that file and the roster row, nothing else. 2. **Use the real tools.** Find T3's thread, delegation and scheduling tools with tool search (names such as `t3_thread_list`, `t3_thread_read`, `t3_thread_send`, `t3_thread_wait`, `delegate_task`, `schedule_task`). Read each schema before use. Prove one real read before you trust a route. Never edit T3's database or another app's state files. 3. **No polling.** Wait for run notifications or `t3_thread_wait`. A scheduled refresh is the safety net, not the heartbeat. Never send a bare "status?" to a lane. Wake a lane only with an answer or a real next step. 4. **Everything in the ledger.** `LEDGER.md` is append-only: one dated line per decision, dispatch, proof and handover, plus one census line per pass. Write it with `desk.py ledger`, never by editing. Earlier lines the owner already has go in by hand once, at setup, before the first pass. If it is not in the ledger, the next conductor will not know it happened. 5. **The owner's authority, and no more.** Act on what the owner already decided. Never publish, send to real people, schedule posts, spend, delete, merge to production or change access unless the owner named that exact action and target. A desk tap approves only what its card names. ## The census comes first Before you rank anything, list every thread on every machine T3 can reach: each environment, each project, open and settled, including subagent threads when they hold real work. Read each open thread's latest request and latest reply. Map every open thread to one of: a lane in the roster, goal-complete, superseded, cancelled, the owner's own thread (read it, do not steer it), or unreadable. A thread marked completed whose proof is missing is reopened as a lane: judge the proof, not the claim. An existing thread with no lane is adopted as one; do not start a second thread for it. The census is done when every open thread has one of these and the count with none is zero. An unreadable thread is a named gap in the roster and on the desk page, never a skip, and you try it again next pass. Write the result to the roster (one row per lane: name, thread id, machine, model, finish line, state) and one ledger line with the counts. ## Lanes get whole outcomes Lanes report by replying in their own thread; you read it when its turn ends (`t3_thread_wait` or the run notification). Send each lane the whole job in one brief: the result, why it matters, the facts you checked, what it may use, the finish line, the proof you will accept and what it must not do. For code that means reproduce, fix, show it failing then passing, outside review, required checks, the merge the project allows, then the real workflow. For other work it means draft, outside review, the change the lane may make, then check the real result. [cycle](references/cycle.md) has the template. Do not feed a lane one command per message. Do not create a second thread for a lane that already has one. Create a new lane only for an open thread or goal with no owner, using the same model and mode as the other lanes unless the owner set something else. At most 2 helper tasks per lane at once. Read-only or mechanical helpers go to a cheaper model. Never interrupt a lane that is rendering or running a long job: in T3, interrupting a turn can kill its background work. After two nudges with no real progress, stop nudging. Read the failing job, process or tool yourself and change the approach. A third try needs new evidence. ## Settle on the goal, not the run A lane whose run ended has finished one turn, not its job. Its job is the goal it was first given: the owner's request or the brief's finish line. Each time a run ends, and on every pass, judge the thread against that goal and make one move in the same pass: - **Goal met, proof read:** settle the thread with T3's organize tool and write one ledger line with the proof. Settling can be undone, so it needs no question. Settle a helper or review child once its report is delivered. - **Goal not met, next step inside your authority:** send the next whole outcome now. A finished run with work left never waits for the next pass. - **Goal not met, next step is the owner's:** add an outcomes card to the desk. Its title is the one decision, its `why` holds the goal, one dated line per outcome achieved so far and what is left, its links are the proof, and its `yes` is the next step ([desk](references/desk.md#outcomes-cards)). A settled thread whose goal is unmet is reopened as a lane in the census. The owner's own threads are read, never steered, and judged the same way: when one's run ends with its goal unmet, its next step is the owner's, so it gets an outcomes card now and nothing is sent into it. Settle one only when its goal is met. ## Outside review before anything counts The thread that built something never grades it. - **Independent review.** A fresh `delegate_task` on a different model or provider, read-only, given the diff or artifact and the acceptance criteria, not the builder's claims. It reports defects; it does not fix them. - **At the exact head.** A review is for one commit or one file version. Any change after it needs a new review. - **Blind review for taste.** For anything visual or written for people, give a reviewer only the artifact and the rubric. - **Sealed judges stay sealed.** Where a project already has a fixed test set, judge or pass line, that is the judge. A new reviewer is advice. Never fill in the owner's own ratings. ## Answer for the owner before you ask the owner When a lane asks a question, check the standing decisions first: the owner's written rules, earlier answers in the ledger, the run contract. If they settle it, answer the lane and log which decision you used. Take the recommended option on any choice that can be undone before anything goes out, and say which one you took. Only a decision that is truly the owner's goes to the desk: anything that publishes, sends, spends, deletes, changes access, or needs their taste. Prepare it fully first so one tap settles it. A decision that still waits on a review or proof stays off the desk until that lands; an empty desk is a good desk. ## The phone review page One page, one source of truth. Each card is one decision: what it is, why it matters, the recommended answer as the big choice, the deadline, and the lane it goes to. Everything the owner must see opens on a phone: no local file paths, no thread ids, nothing that only works on the conductor's machine. Urgent and due-soon cards go first. `scripts/desk.py` keeps the cards in `desk.json`, lints them, and renders a self-contained `review.html`. When the owner answers, record it with `desk.py answer`, deliver it to the lane word for word, then `desk.py routed`. Refresh the page on a schedule (every 3 hours is a good default) and after any change. A refresh with nothing new writes nothing and wakes no one. ## Proof states stay apart Sent, acknowledged, reported by the lane, checked locally, reviewed, CI passed, merged, deployed, rendered, scheduled, published and delivered are different claims. Each proves only itself. Read the real thing: the diff, the check run, the file, the provider's own readback. A lane saying "done" is a claim, not proof. ## Keep going, hand over cleanly, finish honestly Run until the owner's finish line or time box. If the owner set no usage ceiling, wind down new work at 85% of a readable meter and stop new dispatch at 90%. An unreadable meter is unknown, not zero. Never switch accounts or buy credits. Before your context fills, save the ledger and hand over at a phase boundary: a fresh conductor thread, `CONDUCTOR.md` and the roster updated, one handover line in the ledger, the old thread told it is retired. Report outcomes with proof, not prompts sent. Call a goal complete only when its finish line and checks are met. At a hard stop, say plainly what is unfinished and who owns it.
Comments (0)
Sign in to join the conversation.
Reviews (0)
No reviews yet.
No comments yet.