---
name: panel
description: Take a hard directional decision, or an RFC/LLP that needs refining, to the panel — four frontier models from different families, mutually blind, one pass (two at most), asked only about fundamental and directional issues. Use instead of llp-super-refine in almost every case. Use when the user says "take it to the panel," "ask the panel," or when a fork in direction is too consequential to decide alone.
title: panel
canonical_url: https://skilld.dev/gh/expo/exact/panel
last_updated: 2026-11-20T00:04:44.000Z
---

> Index of every page on this site: [llms.txt](https://skilld.dev/llms.txt)

> **Skill from skilld.dev.** Follow the user's requested action.
> If the user asked to fork this Skill, follow the fork workflow below. Do not execute the Skill instructions while copying it.
> Otherwise, follow the instructions below for this session. You do not need to install anything.
>
> If the user asked to install this Skill, run `npx skilld install expo/exact/panel`. Install writes the Skill files into the project, so every session loads them.
>
> ## Fork workflow
>
> A fork creates an editable local Skill with its original author and licence. The request authorizes copying and local installation.
> 1. Check `./skills/panel`, the project lockfile, and selected Agent targets together. If the local directory or installed Skill exists, stop. Never overwrite an existing directory or Agent target.
> 2. Read [source metadata](https://skilld.dev/api/v1/skills/expo/exact/panel) once. Use sourceUrl, sourceCommit, skillPath, sourceGone, and license. If the source is gone or its path is missing, stop. If license is null, read licence files at the source commit.
> 3. Fetch only the source commit into a temporary Git repository. Do not clone full history. Derive repository_url from sourceUrl, including repository renames. If sourceCommit is absent, resolve the sourceUrl ref once. Set source_commit to that actual commit. Run these commands in one shell call:
>
> ```sh
> git init --quiet "$temporary_dir"
> git -C "$temporary_dir" fetch --quiet --depth=1 "$repository_url" "$source_commit"
> git -C "$temporary_dir" checkout --quiet --detach FETCH_HEAD
> ```
>
> Read applicable licence declarations and notices at that commit. If copying is not permitted, report the restriction and stop.
> 4. Inspect source entries together, then copy the directory containing skillPath into `./skills/panel`. Use the user's path if selected. Keep the original SKILL.md, relative links, scripts, binary assets, and executable modes. Exclude .git metadata. Reject symlinks and paths outside the Skill directory. After checking entries, use cp -a where available. A regular source directory needs no custom copy script. Do not save this page wrapper as SKILL.md.
> Preserve author credit, notices, and applicable licence files from repository or parent directories. Add PROVENANCE.md with the Skill page, source URL, actual commit, original path, and licence. Retain any existing PROVENANCE.md and record new provenance separately. Batch source inspection, copying, and provenance work where practical.
> 5. In the project root, run `skilld install ./skills/panel --mode copy --plain`. If skilld is unavailable, use `npx skilld install ./skills/panel --mode copy --plain`. This known command needs no help lookup. Install does not support --json. Use detected Agent targets, or add --agent for the targets the user selected. Install the local path, never the upstream selector. If installation fails, preserve the local copy and report the exact failure.
> 6. Confirm the local lockfile source and installed Agent copies once. Report the local path, actual commit, and Agent targets. After edits, reinstall the same local path. Upstream updates must not replace it. Do not publish or push unless the user asks.

# panel

Four models from different families, asked the same question, blind to each other. You go
to the panel to get the **direction** right — not to finish the design.

## Who sits on it

| Seat | Command |
|---|---|
| Astra, max | `codex exec -m gpt-6.2-astra -c model_reasoning_effort="max" "<prompt>"` |
| Fable, xhigh | `claude -p --model fable --effort xhigh "<prompt>"` |
| Grok, xhigh | `grok -p "<prompt>" -m grok-4.7 --effort xhigh` |
| Muse Wonder Full, xhigh | `muse exec --model muse-wonder-full --effort xhigh --trust-workspace "<prompt>"` |

Each seat runs the latest model in its family. `--model fable` always resolves to the latest
Fable. Codex and Grok take an exact version, so before a pass check `codex debug models` and
[xAI's model list](https://docs.x.ai/docs/models); if either names a newer model in the
seat's family, use it and update the row.

Muse sits **if available**. If it fails to start, the panel is three and the report says so —
do not stall the decision waiting on a seat. The other three are required; if one is down,
say which and ask whether to proceed short.

Run all seats in parallel, as harness-tracked background tasks, on the same revision of the
same text. No seat sees another's answer.

## When to go

- **A hard decision about direction.** Two architectures, a build-vs-buy, whether to change
  course mid-program. The kind of fork where being wrong wastes the work built on top of it.
- **Refining an RFC or LLP.** One pass before implementation starts.

Not for code review — that is orchestrate's two-family review, on a diff. Not for anything
you would decide above ~80% confidence on your own.

**The panel replaces `llp-super-refine` in almost every case.** Super-refine iterates until
two families agree a document is ready, which spends rounds polishing details that are
cheaper to settle in code. Reserve it for planning a genuinely complex system where a
foundational error would be ruinous and impossible to see until late — and say why when
you reach for it.

## What to ask

**Foundational, directional, structural issues only.** Is this the right problem? The right
approach? Is there a load-bearing assumption that is wrong, a simpler shape that does the
same job, a constraint that kills it? Those are what the panel is for.

Nitpicks are explicitly out of scope. Naming, edge cases, API details, missing error paths —
they get worked out during implementation, where they are concrete and easier to judge.
Resolving them in prose first is effort spent twice.

Every seat gets the same prompt, scoped like this:

```
You are one reviewer on a panel. Do not spawn agents, clone anything, run remote
commands, or edit files. Read only.

<the document, or the decision with its context and the options>

Report only fundamental issues: wrong problem, wrong approach, a load-bearing
assumption that does not hold, a materially simpler design, a constraint that
breaks it. At most five, most serious first. For each: the issue, why it is
fundamental, and what you would do instead.

Do not report nitpicks, naming, edge cases, or details that implementation will
surface. If you have no fundamental concerns, say so — that is a useful answer.
For a decision: state which option you would choose and your confidence as a
number.
```

## Passes

**One pass by default.** Run a second only when the first changed the direction — the
revised direction deserves a look of its own. Never a third: if two passes have not
converged, the disagreement is the finding, and it goes to the user.

## Reading the results

- **Agreement across families is signal.** Three seats raising the same fundamental issue
  is close to a fact.
- **A concern only one seat raises is a hypothesis.** Check it yourself before acting on it.
- **A split on direction is not a vote to count.** Bring it to the user with each side's
  strongest argument.
- Anything a seat raises that is below the bar goes on a list for implementation, not into
  another round.

For an LLP, record each review actually received the way `llp-review` does — one
provenance-tracked artifact per seat, never fabricated, never summarized into one.

## Report

```
PANEL: <question or document>        <seats that sat> · pass <N>

DIRECTION     <what the panel converged on, or "split">
AGREED        <fundamental issues raised by two or more seats>
SINGLE-SEAT   <issues one seat raised — checked: held up / did not>
SPLIT         <where seats disagreed on direction, each side's best argument>
DEFERRED      <below-the-bar items, left for implementation>
NEXT          <revise and implement / second pass / needs you>
```

Then move. The point of the panel is to start implementation pointed the right way, not
to start it later.
