agentleFS
diegoferigodiegoferigo/dotfiles/.agents/skills/coordinating-sessions/SKILL.md

coordinating-sessions

Skill4 starsChanged 4 days agoMITView on GitHub

Use for any coding, debugging or exploration session beyond a quick question that touches several files or steps, without the ledger of orchestrating-agents. The main agent plans and edits, a fast model does the mechanical reads and commands, and a stronger advisor is consulted before a non-trivial plan locks, after the same error twice, before declaring done, before a hard-to-undo action and when two designs compete. For many tasks, parallel writers, worktrees or crash recovery use orchestrating-agents.

1 other project uses a version of this.

Adopted by

Most recently taken up by

The file

Files
SKILL.md

Coordinating sessions

The default for sessions that are more than a quick question and less than a pipeline: cheap models for routine turns, the strongest model only for the big calls, and no ledger. The main agent stays the single writer and the decision maker.

Contents

  • Roles
  • Delegate mechanical work to the fast model
  • Delegate a bounded task
  • Consult the advisor
  • Change the model or the thinking level
  • When to switch to orchestrating-agents

Roles

roledoesCopilot CLI
main agenttalks to the user, plans, edits code, decidessession model
fast modelmechanical work only: read, search, run a command, reportexplore and task agents
advisorindependent judgment on the big calls, read-onlyadvisor agent
stronga bounded task that needs judgment, delegated to the strongest modelgeneral-purpose agent with the strongest model

Models are configured in the tool, not here: for Copilot CLI in ~/.copilot/settings.json (subagents.agents).

Delegate mechanical work to the fast model

The fast model is an executor, not a thinker. Give it a task with no decision in it and an exact thing to report:

  • Exploration that would take more than about five reads or searches: ask for paths, symbols and short quotes. Launch independent searches in parallel.
  • Build, test or lint runs: ask for the command, the result and the first error.
  • Mechanical lookups and summaries: grep, listing, reading a long log.

Never give it an ambiguous task, a design choice, a diagnosis or an edit that needs judgment. The fast model reports, the main agent decides. Verify a claim that drives an edit by reading the file. A known file, a single edit or a quick question: do it directly.

Delegate a bounded task

Delegate an edit only when it is small, has a clear interface and does not overlap the files you are changing. Keep at most two or three in flight, each on a different set of files. The main agent does the routine ones itself or hands them to a subagent on the session model. Use the strong model for a bounded task that needs deep judgment, such as a hard debugging hypothesis, a subtle algorithm or a risky refactor of one module.

  • Give a self-contained brief: goal, files it may touch, acceptance check, and the constraints from the active repo and persona skills. Subagents do not inherit loaded skills.
  • Review each result by evidence before you accept it: read the diff and the command output, not the summary.
  • Track the tasks in the session task list the tool provides. A file or a note is not needed.
  • You commit and integrate. Run the full check yourself after the last task returns.

Consult the advisor

  1. Before a non-trivial plan locks, after exploring and before the first edit.
  2. After the same error twice: it must not be a third variation of the same attempt.
  3. Before declaring the work done, with the evidence of the checks that ran.
  4. Before an action that is hard to undo: push, force-push, migration, deletion, a change to shared data.
  5. When two defensible designs compete and the choice is costly to change later.

Skip it for a trivial change, a question or a one-line fix.

The advisor may not see the conversation, so pass a self-contained brief: the goal, the plan or diff, what was tried, the evidence (command and first error, or the check summary) and one question. Do not ask it to implement. It is read-only by design: it may run commands only to read state or to check a claim (git diff, tests, linters, searches).

Apply the answer: adopt findings that prevent a real problem, set aside the ones that add complexity without benefit, and say which in one line. Consulting is best effort: the instructions are followed by the main agent, not enforced. If the advisor says stop, stop and report to the user. When your own evidence contradicts a finding, say so instead of following it blindly.

Change the model or the thinking level

Defaults come from the tool configuration, so leave a delegation call without overrides. Change them only for a reason: a hard diagnosis may need more thinking, a mechanical task needs none.

  • Persistent default per agent (Copilot CLI): subagents.agents.<agent> in ~/.copilot/settings.json takes model, effortLevel and contextTier, each of which can be "inherit" to follow the session. The /subagents command edits the same values.
  • One call (Copilot CLI): the agent tool accepts model and reasoning_effort per call. Set them when the user or the active instructions ask for it, or when the task clearly needs more or less thinking than the default. Raise the thinking level before the model when the task is the right one but the answer is shallow.

When to switch to orchestrating-agents

Load orchestrating-agents instead when any of these holds: more than about four tasks, parallel writers that need their own worktrees, a stack of pull requests, a review or CI loop that must survive a crash, or a plan you want written to a ledger.

In a borderline case, for example about four tasks that touch separate files, or a session that grows while you work, ask the user in one focused question whether to switch. Say what the ledger would add and what it costs. In an unattended run, stay here, say so in one line and switch only if a clear criterion above is met.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.