Насколько быстр Claude Code? Токены в секунду, измеренные на 20 000 ходов

Claude Code многое рассказывает о токенах. /usage показывает, какую часть сессии и недели ты уже израсходовал, монитор сессий в AgentsRoom считает входные и выходные токены, чтение и запись кэша ход за ходом, а строка состояния может выводить занятую долю контекстного окна. Ни один из них не показывает то единственное число, которое люди продолжают искать: сколько токенов в секунду модель на самом деле производит, пока ты ждёшь.

Это число не спрятано, его просто никто не считает. Каждое сообщение каждой сессии попадает в JSONL-транскрипт в ~/.claude/projects/, и каждое сообщение ассистента несёт временную метку и расход токенов. Так что мы посчитали его сами, на своей машине, за последние четыре недели. Вот метод, скрипт и то, что получилось.

Токены в секунду у Opus 5.5: обновление от 19 октября 2026 года

Мы повторили измерение на последних четырёх полных неделях: с 21 сентября по 18 октября 2026 года включительно (UTC). Мы учли каталог транскриптов по умолчанию и дополнительные профили Claude, которые использует AgentsRoom, а затем посчитали каждый запрос только один раз по всем файлам.

Фиксированное время это свободный член линейной регрессии прошедших секунд по выходным токенам методом наименьших квадратов. Это оценка постоянной задержки на каждый ход, а не цена и не прямое измерение времени до первого токена. Рассуждение входит в обе скорости.

Это обновление также исправляет хронометраж. Прямым родителем может оказаться техническое вложение, в том числе deferred_tools_record, записанное, когда ответ уже приходит. На одном запросе старый метод делил 562 токена на 0,046 секунды и получал больше 12 000 tok/s. Если пройти по цепочке родителей назад до сообщения пользователя или результата инструмента, который запустил ход, возвращается примерно семь секунд прошедшего времени. С этой поправкой и дедупликацией запросов ни один запрос Opus 5.5 в этом окне не превышает 400 tok/s; высокие скорости мы не отфильтровывали.

Сентябрьские таблицы ниже остаются исходным измерением. Их медиана 94,9 tok/s и взвешенная скорость 109,3 tok/s получены со старым хронометражем и на другой выборке, поэтому разница не доказывает, что Opus 5.5 стал медленнее. Эти цифры описывают наши задачи, нашу сеть и временные метки транскриптов, а не изолированный бенчмарк модели.

Откуда берутся данные

Claude Code пишет по одному файлу на сессию в ~/.claude/projects/<project slug>/<session id>.jsonl. Одна строка на событие. Здесь важны строки с сообщениями ассистента, и каждая выглядит так, если оставить только полезные поля:

{
  "type": "assistant",
  "uuid": "24d13076-…",
  "parentUuid": "d4447285-…",
  "requestId": "req_011CepWq…",
  "timestamp": "2026-09-07T18:00:08.412Z",
  "message": {
    "model": "claude-opus-5",
    "usage": {
      "input_tokens": 2,
      "cache_read_input_tokens": 0,
      "cache_creation_input_tokens": 51591,
      "output_tokens": 200,
      "output_tokens_details": { "thinking_tokens": 0 },
      "speed": "standard"
    }
  }
}

Измерение возможно благодаря четырём вещам:

• timestamp записывается в момент добавления блока контента, поэтому последний блок хода датирован концом потоковой выдачи.
• parentUuid указывает на предыдущее событие, которым может оказаться техническое вложение, записанное во время ответа. Нужно пройти по цепочке дальше, пропуская события attachment, system и progress, до сообщения пользователя или результата инструмента, который запустил ход; его временная метка служит приближённой оценкой начала хода.
• requestId группирует блоки одного вызова API. Ход, который пишет немного текста, а затем вызывает инструмент, создаёт две строки ассистента с одинаковым requestId и одинаковым usage, поэтому токены нужно считать один раз на запрос, а не один раз на строку.
• usage.output_tokens это весь вывод запроса, включая рассуждение; output_tokens_details.thinking_tokens показывает, какая его часть пришлась на рассуждение.

Ничто в файле не даёт время до первого токена. Измерить можно весь ход: от ухода запроса с твоей машины до прихода последнего токена. Это ещё и единственное число, которое ты ощущаешь, пока ждёшь, поэтому мы оставили именно его.

Метод

Для каждого requestId: взять первую и последнюю строки ассистента с этим идентификатором, прочитать usage из первой, пройти по цепочке её родителей до сообщения пользователя или результата инструмента, который запустил ход, и разделить выходные токены на число секунд, прошедших до последней строки ассистента. Считать запрос один раз по всем файлам и показывать каждую модель и каждый режим скорости отдельно. Эти временные метки включают локальные задержки; время генерации на стороне API они не выделяют.

Мы отбрасываем ходы без выходных токенов, без найденного запускающего события, с неположительной длительностью или с длительностью больше пятнадцати минут. Скрипт ниже использует окно датированного обновления: начало включено, конец исключён, в UTC. Измени START и END, чтобы измерить другой период.

Обновлённому скрипту нужен Python 3.10 или новее, дополнительных зависимостей нет. Запускай его откуда угодно: он читает проекты из каталога по умолчанию и дополнительные локальные профили Claude, никуда не отправляя их содержимое.

import json, glob, os, statistics as st
from datetime import datetime
from collections import defaultdict

START, END = "2026-09-21", "2026-10-19"  # UTC, end exclusive
PATTERNS = ("~/.claude/projects/*/*.jsonl",
            "~/.agentsroom/claude-profiles/*/projects/*/*.jsonl")

def ts(s): return datetime.fromisoformat(s.replace("Z", "+00:00")).timestamp()

def read_session(path):
    by_uuid, groups = {}, defaultdict(list)
    with open(path) as fh:
        for line in fh:
            try: o = json.loads(line)
            except ValueError: continue
            if "uuid" in o: by_uuid[o["uuid"]] = o
            msg = o.get("message") or {}
            if o.get("type") == "assistant" and msg.get("usage") and o.get("timestamp"):
                groups[o.get("requestId") or o["uuid"]].append(o)
    return by_uuid, groups

def trigger(first, by_uuid):
    parent, visited = by_uuid.get(first.get("parentUuid")), set()
    while parent and parent.get("type") in ("attachment", "system", "progress"):
        uid = parent.get("uuid")
        if uid in visited: return None
        visited.add(uid)
        parent = by_uuid.get(parent.get("parentUuid"))
    return parent if parent and parent.get("type") == "user" else None

by_model, seen = defaultdict(list), set()
for pattern in PATTERNS:
    for path in glob.glob(os.path.expanduser(pattern)):
        by_uuid, groups = read_session(path)
        for rid, blocks in groups.items():
            first, last = blocks[0], blocks[-1]
            if rid in seen or not START <= first["timestamp"] < END: continue
            usage = first["message"]["usage"]
            out, parent = usage.get("output_tokens", 0), trigger(first, by_uuid)
            if not parent or not parent.get("timestamp") or out <= 0: continue
            dur = ts(last["timestamp"]) - ts(parent["timestamp"])
            if not 0 < dur <= 900: continue
            seen.add(rid)
            thinking = (usage.get("output_tokens_details") or {}).get("thinking_tokens", 0)
            key = first["message"].get("model"), usage.get("speed", "unknown")
            by_model[key].append((out, dur, thinking))

for (model, speed), rows in sorted(by_model.items(), key=lambda kv: -len(kv[1])):
    outputs, durations, thinking = zip(*rows)
    median = st.median(o / d for o, d, _ in rows)
    weighted = sum(outputs) / sum(durations)
    overhead = st.linear_regression(outputs, durations).intercept if len(set(outputs)) > 1 else float("nan")
    print(f"{model} {speed}: turns={len(rows)} median={median:.1f} "
          f"weighted={weighted:.1f} tok/s overhead={overhead:.2f}s "
          f"thinking={100 * sum(thinking) / sum(outputs):.1f}%")

Колонка weighted это сумма токенов, делённая на сумму секунд. Так скорость ощущает длинный автономный прогон; медиана показывает, как её ощущает отдельный интерактивный ход.

Цифры

Один Mac во Франции, 319 транскриптов, 20 408 ходов с 27 августа по 25 сентября 2026 года, 12,0 миллиона выходных токенов за 45 часов генерации. Стандартная скорость на каждом ходе (про быстрый режим ниже). В транскриптах встречаются пять моделей, под теми названиями, которые пишет Claude Code.

Сначала два наблюдения. Во-первых, Opus 5.5 не чуть-чуть быстрее Opus 5: по медиане он быстрее в полтора раза, а по взвешенной скорости на 57%, притом что длинных ходов у него гораздо больше. Во-вторых, разброс внутри одной модели шире, чем разрыв между моделями: ход Opus 5 на 25-м перцентиле выдаёт 51 токен в секунду, а на 75-м 72. Причина в размере хода, и она заслуживает отдельного раздела.

Короткий ответ всегда медленнее

Снова Opus 5, теперь в разбивке по числу выходных токенов в ходе:

Та же модель, тот же месяц, та же машина, а скорость между однострочным ответом и длинным удваивается. На длинных ходах модель не выдаёт поток быстрее. Каждый ход несёт фиксированные затраты времени, прежде чем появится первый токен: запрос уходит, промпт обрабатывается, потоковая выдача стартует. На ходе в 80 токенов эти затраты составляют треть прошедшего времени; на ходе в 3 000 токенов они теряются в шуме.

Линейная регрессия длительности по выходным токенам методом наименьших квадратов разделяет эти две составляющие. Наклон даёт скорость потоковой выдачи, свободный член даёт фиксированные затраты:

Поэтому, когда сессия с кучей вызовов инструментов кажется медленной, дело редко в пропускной способности модели. Дело в числе ходов. Агент, который читает двенадцать файлов по одному, двенадцать раз платит фиксированные затраты; тот же агент, читающий их одним пакетным вызовом, платит один раз. Это тот же урок, что и в статье о том, как сократить расходы на токены: меньше ходов, но крупнее, а не более быстрая модель.

Самый длинный ход корпуса: 21 332 выходных токена за 236 секунд на Opus 5, то есть 90 токенов в секунду от начала до конца. Когда фиксированные затраты амортизированы, это потолок, который мы наблюдали на этой модели при стандартной скорости.

Токены рассуждения тоже выходные токены

output_tokens включает рассуждение, которое модель проводит перед ответом, а output_tokens_details.thinking_tokens показывает его объём. В нашем корпусе рассуждение составляет 30% всего, что выдал Opus 5, 18% у Opus 5.5, 36% у Fable 5.1 и 54% у Sonnet 5, который мы в основном запускали на более высоком уровне усилий для задач ревью.

Это важно, когда разбираешь медленный ход. Ход, который рассуждает восемь секунд и выводит две строки, это не медленная модель, а ход, который произвёл 600 токенов, которых ты так и не увидел. Ходы с рассуждением в пересчёте на токен даже немного быстрее ходов без него: 67 против 57 токенов в секунду на Opus 5, потому что они длиннее и лучше амортизируют фиксированные затраты. Если сессия кажется вялой, а рассуждение тебе не нужно, рычаг здесь уровень усилий, а не модель.

Чтение кэша меняет счёт, а не скорость

Почти каждый ход в Claude Code попадает в кэш промптов: только у 130 из 16 680 ходов Opus 5 значение cache_read_input_tokens было равно нулю, и это первые ходы сессий. На ходах от 100 до 500 выходных токенов кэшированные выдают в медиане 60,6 токена в секунду и занимают 3,4 секунды; некэшированные выдают 58,0 и занимают 3,7 секунды. Разница реальна, но мала, и она сидит в фиксированных затратах, а не в скорости потоковой выдачи. Кэширование касается цены контекста, который ты несёшь с собой, и именно поэтому счётчик токенов в терминале AgentsRoom показывает чтение и запись кэша отдельными цифрами.

Стабильно в течение месяца

Накопленное число может скрыть дрейф, поэтому мы посмотрели и на недельную медиану Opus 5 на ходах от 100 до 500 токенов, самых частых: 63,6, 64,1, 60,9, 61,7, 56,9 токена в секунду неделя за неделей, затем 68,7 за последнюю, неполную неделю. Между 57 и 69, без тренда. Если однажды днём твои сессии кажутся медленнее, стоит прогнать скрипт только по этому дню, прежде чем винить модель.

Что меняет быстрый режим и что мы не смогли измерить

Каждый блок usage содержит поле speed, и во всех наших 20 408 там стоит standard. Anthropic описывает быстрый режим для Claude Opus, который включается командой /fast в CLI или "fastMode": true в пользовательских настройках и делает модель до 2,5 раза быстрее при более высокой цене за токен: 8 долларов за миллион входных токенов и 40 за миллион выходных на Opus 5.5, 10 и 50 на Opus 5 и Opus 4.8. На тарифах Pro и Max он списывается с кредитов использования, вне окон подписки; Sonnet и Haiku его не поддерживают, а его включение переключает тебя на Opus. Иконка молнии рядом с полем промпта показывает, что он включён.

Мы за него не платили, поэтому измеренной цифры, которую можно поставить рядом с заявленными 2,5 раза, у нас нет. Если ты им пользуешься, тот же скрипт покажет, что ты получил: отфильтруй ходы по usage["speed"] == "fast" и сравни медианы. Пришли нам цифры.

Что это меняет в том, как мы запускаем агентов

Три вещи, и ни одна не про выбор более быстрой модели.

Первая касается ожиданий. Если ночной прогон семи агентов производит два миллиона выходных токенов, это восемь часов генерации при 70 токенах в секунду, распределённых между агентами, которые работают параллельно. Зная скорость, можно сказать, успеет ли запланированная задача закончиться до старта следующей.

Вторая касается ходов. Фиксированная секунда на ход одинакова и для подтверждения в 30 токенов, и для диффа в 3 000 токенов. Агенты, которые спрашивают перед каждым мелким шагом или читают файлы по одному, проводят своё время в этой секунде. Поэтому мы пишем «группируй независимые чтения» в промпты агентов, которые работают без присмотра.

Третья касается того, что должен показывать счётчик. Монитор сессий в AgentsRoom показывает токены и кэш и краснеет, когда сессия становится тяжёлой; скорость он не показывает, и после этого измерения мы не уверены, что должен. Скорость это свойство модели и размера хода, а не сессии, и число, которое нужно разработчику, есть в таблицах выше. Поэтому это статья, а не виджет.

Частые вопросы

Сколько токенов в секунду генерирует Claude Opus 5.5?

По нашему измерению, обновлённому 19 октября 2026 года, Claude Opus 5.5 выдал медиану 89,4 выходного токена в секунду на 30 119 уникальных запросах с 21 сентября по 18 октября, все на стандартной скорости. Сумма выходных токенов, делённая на сумму прошедших секунд, даёт 97,5 tok/s. Рассуждение составляет 42,1% выходных токенов. Это сквозные измерения по транскриптам наших собственных сессий, а не универсальный бенчмарк скорости потоковой выдачи.

Сколько токенов в секунду генерирует Claude Code?

На наших 20 408 ходах, записанных с 27 августа по 25 сентября 2026 года: у Opus 5 медиана 63 выходных токена в секунду (69, если разделить все токены на все секунды), у Opus 5.5 95 (109), у Sonnet 5 77 (87), у Fable 5.1 75 (80) и у Opus 4.8 61 (64). Эти цифры охватывают весь ход, от момента, когда запрос уходит с твоей машины, до последнего полученного токена, так что это ровно то время, которое ты реально ждёшь.

Показывают ли /usage или /cost токены в секунду?

Нет. /usage показывает квоту твоего тарифа, 5-часовое и недельное окна и занятую долю контекстного окна; /cost это псевдоним /usage. Ни одна из команд не выводит скорость. Единственное место, где скорость существует, это транскрипт сессии в ~/.claude/projects/, где каждое сообщение ассистента несёт временную метку и число выходных токенов. Именно его читает скрипт из этой статьи.

Почему короткий ответ кажется медленнее длинного?

Потому что каждый ход несёт фиксированные затраты времени до прихода первого токена: отправка запроса, обработка промпта, запуск потоковой выдачи. В наших данных эти накладные расходы составляют около секунды на Opus 5 и Opus 5.5 и полсекунды на Sonnet 5. На ответе в 80 токенов одна секунда это треть хода, поэтому измеренная скорость падает до 40 токенов в секунду; на ответе в 3 000 токенов та же секунда растворяется, и скорость поднимается до 80 и выше. Сама скорость потоковой выдачи постоянна.

Учитываются ли токены рассуждения в скорости?

Да. Блок usage каждого сообщения сообщает output_tokens с разбивкой output_tokens_details.thinking_tokens, и токены рассуждения входят в output_tokens. В нашем корпусе они составляют 30% всего, что выдал Opus 5, 18% у Opus 5.5 и 54% у Sonnet 5, который в основном работал на более высоком уровне усилий. Ход, который долго рассуждает, не медленный: он производит токены, которых ты не видишь.

Делает ли кэширование промптов Claude Code быстрее?

Скорость вывода нет. На ходах от 100 до 500 токенов Opus 5 выдаёт в медиане 60,6 токена в секунду, когда запрос попадает в кэш промптов, и 58,0, когда не попадает, а весь ход занимает 3,4 секунды против 3,7. Кэширование влияет на то, сколько ты платишь за контекст, а не на то, как быстро выходит ответ.

Что такое быстрый режим Claude Code и насколько он быстрее?

Это конфигурация Claude Opus, которую Anthropic описывает как работающую до 2,5 раза быстрее, по более высокой цене за токен: 8 долларов за миллион входных токенов и 40 за миллион выходных на Opus 5.5, 10 и 50 на Opus 5 и Opus 4.8, со списанием с кредитов использования, а не с окон подписки. Он включается командой /fast, и рядом с полем промпта появляется маленькая иконка молнии. Ни один из 20 408 измеренных нами ходов не шёл в быстром режиме (каждый транскрипт пишет speed: standard), поэтому измеренной цифры для него у нас нет; цифры в этой статье даны для стандартной скорости.