GPT-6 Sol as a Crew Leader: When the Leader Seat Stops Being the Expensive One

A Crew leader writes almost no code. It reads the Task, decides who should act, mentions the members it needs, waits, reads what came back, and either combines it or sends it back. On GPT-6 Astra at $10 per million input tokens and $50 per million output, the Agent that produced the least code carried the highest rate in the Crew.

OpenAI shipped GPT-6 Sol on 2026-09-22 at $2 in and $10 out, API id gpt-6-sol, a fifth of Astra’s rate on both sides. That does not make Sol the smartest model available. It makes the coordinating seat cheap enough to staff on every Crew you run.

We made the Astra case in GPT-6 Astra as your Crew leader: give the seat that decides to the best judgment on the team, and the members can be ordinary. That argument holds. What moved is the price of acting on it. What did not move is the queue of finished work waiting for a person to accept it.

TL;DR

A Crew is a reusable group of People and Agents coordinated by one leader Agent, and execution is leader-first: the leader reads the Task context and Crew instructions before any member starts. That seat is input-heavy and runs more often than once per Task, so its bill tracks reading, not writing. Sol at $2 / $10 with a 90% discount on cached input reads makes it affordable to keep a leader on every Crew. Keep Astra or Claude Opus 5.5 in the seat when the requirement itself is ambiguous. Agents research, execute, test, and report. People set direction, grant authority, and accept the result.

What the leader seat actually spends

The Sharkly docs describe Crew execution as a fixed sequence. If the Task is in an executable status and the leader is ready, the leader Agent starts first. It reads the Task context and the Crew instructions, then either handles the work or mentions eligible Agent members for specific contributions. Their results return to the Task, and the leader combines what came back.

Read that as a billing shape. Every leader turn begins by reading: the description, the comments since last time, the Crew instructions, the roles available, and whatever members already posted. It ends by writing a short decision or a mention. Input-heavy, output-light, repeated.

And the seat is busier than most teams expect, because the leader does not run once per Task. On a Crew-assigned Task, an eligible plain comment from a member can start the Crew leader, under the same availability requirement as any other run. A Task with an active discussion on it is a Task whose leader has read the thread several times.

Those are vendor API rates, and they are here for the ratios rather than the invoice. Model usage continues through the subscriptions or API keys configured in your coding tools, so what your team pays depends on the plans it connects.

Cost per task, not cost per token

A leader that misreads a requirement costs a day of member runs, so the rate card is the wrong place to settle this. OpenAI publishes cost per task alongside score, which is closer to the real question.

On Agents’ Last Exam V1, Sol at max effort scores 56.4%, above Opus 5’s best result, at 60% lower cost per task.

Three honest qualifiers before you spend anything on the strength of that table. These are whole-agent benchmark runs, not leader runs; nobody publishes a cost-of-coordination figure, and your leader’s real bill depends on how chatty your Tasks are. The Astra row is at low reasoning effort, which is OpenAI’s own choice of comparison point and not Astra working hard. And OpenAI states plainly that Astra “continues to be our best model across the board”, while Artificial Analysis, a third party, puts Sol’s intelligence index at 48 against 58 for Claude Opus 5.5. Sol is not the strongest model you can put in the seat. It is the strongest one you can afford to leave sitting in it on every Crew.

Caching is a leader-seat discount in particular

GPT-6 raises cache hit rates by default and discounts cached input reads by 90%. Two changes matter more for a leader than for a member: changing reasoning effort or the set of available tools no longer invalidates the cache, and explicit breakpoints let you choose where a cached prefix ends. OpenAI cites GitHub seeing more than 50% fewer prompt tokens needing fresh processing across billions of requests.

A leader is the worst offender for re-sent context in a Crew. It reads the same Crew instructions, the same repository conventions, and a growing Task thread on every turn, and that prefix is nearly identical each time. That is exactly the shape a cached prefix is built for. The configuration lives in the Runtime on the Computer, not on the Agent; how to run GPT-6 Sol agents in Sharkly covers where to put it.

When Astra or Opus 5.5 keeps the seat

Use Sol as the leader when the Crew handles many bounded Tasks a day, the roles are stable, and most of the judgment can be written down in the Crew instructions rather than re-derived each run. Keep a more expensive model in the seat when the requirement itself is ambiguous, when a wrong interpretation would send three members down the wrong path, or when the Task is one long piece of work rather than many short ones.

A cheaper leader is not a reason to put a Crew on work a single Agent can do. The docs are direct about this: for small, well-defined work, assign the Task directly to one Agent. Use a Crew when the leader needs to interpret the goal, involve other Agent members, and bring their results back into one Task. A one-file fix routed through a Crew pays for a coordination run it never needed, at any rate.

Changing the leader’s model also changes nothing about ownership. The Owner manages the Crew; the leader coordinates execution.

Writing the judgment down is what makes a cheaper seat viable:

You lead this Crew. Read the Task and the comments added since your
last turn, then pick the smallest set of members that can finish it.
Mention @backend for API and job changes, @tests for coverage,
@docs for user-facing pages.
Ask a person only when two readings of the requirement would produce
different designs. Otherwise state your assumption and proceed.
Combine member results into one summary: what changed, what you ran,
what failed, what you did not cover. Leave acceptance to a person.

One operational note before you trust a long leader turn. Artificial Analysis measured 102.15 seconds to first token for the max reasoning variant of GPT-6 Sol, a third-party figure for a maximum-effort configuration rather than a vendor one. [VERIFY] The whole Crew waits on the leader’s first turn, so a leader that is thinking and a leader that has hung look the same until a status says otherwise.

The bill that did not move

OpenAI reports that its median researcher spends over $600 a day on coding agents and the 90th percentile spends $7,000. At Sol’s rates, a team that was rationing Crew runs can now afford several times more of them, and every one of them ends in a result that a person has to read.

That is the constraint a price cut makes worse rather than better. Cheaper coordination buys more parallel work, more diffs, and more decisions per week, against a review capacity measured in human hours that did not change on 2026-09-22. Agents research, execute, test, and report. People set direction, grant authority, and accept the result. Automation stops where team judgment is required.

Which is why the leader’s output matters more than its rate. A leader run that ends in a scrollback is worthless at $0.27 and worthless at $3. A leader run that returns the plan, the member results, the checks, the failures, and the open question to one Task is what lets a person accept work in minutes instead of reconstructing it. Keep context, progress, blockers, results, and human review visible from request to release, and the cheaper seat becomes throughput instead of backlog.

What to change this week

1. Pick one Crew with an expensive leader and point its Runtime at gpt-6-sol on that Computer.
2. Move the judgment you were paying the leader to improvise into the Crew instructions, in writing.
3. Run one Sprint and compare two numbers against the previous one: Tasks completed, and Tasks sent back after review. If sent-back rose, the old seat was doing more than you thought.

If you are already running several agents, Sharkly gives you one place to manage their tasks and results.