Grok 4.7 против Grok 4.6: одинаковая цена и контекст — в чём разница и что выбрать

TL;DR: для сложного кодинга и agentic-задач выбирайте Grok 4.7, для лёгких задач с экономией токенов — Grok 4.6. Оба поколения в HiAPI стоят абсолютно одинаково (вход $0.84 / выход $2.52 за миллион токенов) и имеют одинаковый контекст 500K, так что решает только тип задачи. Grok 4.7 уже доступен в HiAPI — откройте страницу модели и попробуйте сразу, новым пользователям при регистрации дарим 200 кредитов.

Кратко: в чём разница между поколениями

Параметр	Grok 4.7	Grok 4.6
Цена платформы (за миллион токенов, вход/выход)	$0.84 / $2.52	$0.84 / $2.52 (та же цена)
Контекст	500K	500K
Способности к кодингу (Terminal-Bench 4.0, официальные данные)	38.0%	20.3%
Позиционирование	Официально рекомендуется по умолчанию, упор на кодинг и agentic-задачи	Флагман предыдущего поколения, в продаже
Расход токенов (третья сторона traictory.com, высокий effort без ограничения)	Около 81K на задачу, примерно вдвое больше, чем у 4.6	Ниже
Уровни рассуждения	low / medium / high / xhigh, по умолчанию high	Так же
Дата отсечки знаний	2026-05	Раньше

Цена, контекст и уровни рассуждения полностью совпадают, настоящий водораздел — способности к кодингу и привычки вывода. Ниже два теста с одинаковыми промптами.

Один и тот же промпт (1): задача на код LRU-кэша

Протестировано 2026-10-29 в продакшене HiAPI, одинаковые параметры с обеих сторон (уровень рассуждения по умолчанию high, ограничение max_tokens), по одному запуску каждой модели:

Промпт:

Напиши класс LRU-кэша на Python: get и put за O(1), поддержка TTL (автоматическое истечение), потокобезопасность. Дай только код и не более 5 строк инструкции по использованию.

Ответ Grok 4.7 (39.7 с, 3285 токенов на выход, около $0.011):

class LRUCache:
    def __init__(self, capacity: int, default_ttl: Optional[float] = None):
        if capacity <= 0:
            raise ValueError("capacity must be positive")
        self.capacity = capacity
        self.default_ttl = default_ttl
        self._data: OrderedDict[Hashable, tuple[Any, Optional[float]]] = OrderedDict()
        self._lock = threading.Lock()

    def get(self, key: Hashable, default: Any = None) -> Any:
        with self._lock:
            item = self._data.get(key)
            if item is None:
                return default
            value, expire_at = item
            if expire_at is not None and time.monotonic() >= expire_at:
                del self._data[key]
                return default
            self._data.move_to_end(key)
            return value

    def put(self, key: Hashable, value: Any, ttl: Optional[float] = None) -> None:
        with self._lock:
            ttl = self.default_ttl if ttl is None else ttl
            if ttl is not None and ttl <= 0:
                self._data.pop(key, None)
                return
            expire_at = None if ttl is None else time.monotonic() + ttl
            if key in self._data:
                self._data.move_to_end(key)
            elif len(self._data) >= self.capacity:
                self._data.popitem(last=False)
            self._data[key] = (value, expire_at)

(Полный текст включает импорты и пример использования; выше — основная часть; 4.7 использует time.monotonic() для TTL и поддерживает передачу значения по умолчанию в get.)

Ответ Grok 4.6 (61.9 с, 3915 токенов на выход, около $0.012):

class LRUCache:
    def __init__(self, capacity, default_ttl=None):
        if not isinstance(capacity, int) or capacity < 1:
            raise ValueError("capacity must be positive int")
        self.capacity = capacity
        self.default_ttl = default_ttl
        self._cache = OrderedDict()
        self._lock = threading.Lock()

    def get(self, key):
        with self._lock:
            if key not in self._cache:
                return None
            value, expire_at = self._cache[key]
            if expire_at is not None and time.time() > expire_at:
                del self._cache[key]
                return None
            self._cache.move_to_end(key)
            return value

    def put(self, key, value, ttl=None):
        with self._lock:
            now = time.time()
            expire_at = None
            effective_ttl = ttl if ttl is not None else self.default_ttl
            if effective_ttl is not None:
                expire_at = now + effective_ttl
                if expire_at <= now:
                    if key in self._cache:
                        del self._cache[key]
                    return
            if key in self._cache:
                self._cache.move_to_end(key)
            elif len(self._cache) >= self.capacity:
                self._cache.popitem(last=False)
            self._cache[key] = (value, expire_at)

Оба варианта кода полностью удовлетворяют требованиям: OrderedDict обеспечивает O(1), TTL реализован ленивым истечением, threading.Lock — потокобезопасность; оба запускаются сразу.

Один и тот же промпт (2): задача на рассуждение про бассейн

Есть бассейн: одна труба наполняет его за 6 часов, сливная труба опустошает за 8 часов. Сейчас бассейн пуст; открываем одновременно обе трубы. Через сколько часов бассейн наполнится ровно? Сначала напиши ход рассуждения, затем ответ.

	Grok 4.7	Grok 4.6
Время / токенов на выход	8.3 с / 573	18.5 с / 637
Ответ	24 часа	24 часа

Обе модели записали в LaTeX полный ход решения 1/6 − 1/8 = 1/24 → 1 ÷ 1/24 = 24, вывод и рассуждение эквивалентны.

Заметные различия

• На задаче на код 4.7 быстрее на 22 секунды (39.7 с против 61.9 с), а вывод при этом короче (3285 против 3915 токенов)
• На задаче на рассуждение обе ответили верно, ход решения эквивалентен
• В привычках вывода 4.7 чаще использует структурированные заголовки и формулы LaTeX, текст компактнее; 4.6 тоже использует LaTeX, но чуть более многословен (637 против 573 токенов)
• В этом тесте с ограничением (max_tokens) выходных токенов у 4.7 не больше, чем у 4.6. Данные третьей стороны traictory.com («около 81K токенов на задачу, примерно в 2 раза больше, чем у 4.6») получены при высоком effort без ограничения — эти два набора данных не противоречат друг другу, но и не должны смешиваться
• По официальным данным, Terminal-Bench 4.0 вырос с 20.3% до 38.0%, что совпадает с ощущениями от задачи на код выше
• Эти два сравнения и ещё 5 сценариев прогонов (отладка, ревью кода, проектирование решений и т. д.) — всего 9 запросов — все завершились нормально (finish=stop), без обрезания

Как выбирать по сценариям

• Для сложного кодинга и длительных agentic-задач выбирайте Grok 4.7
• Для повседневных лёгких вопросов, преобразования форматов и простых скриптов выбирайте Grok 4.6 — качество вывода не хуже, а токенов меньше
• Если вы уже стабильно используете 4.6, принудительно мигрировать не нужно; новые задачи сначала пробуйте на 4.7, при неудовлетворённости всегда можно вернуться назад
• Если бюджет ограничен, а хочется возможностей 4.7: оба поколения стоят одинаково, разница в расходе, поэтому для лёгких задач 4.6 и есть экономия

Стоимость переключения: меняется одно поле

Оба поколения работают через один и тот же интерфейс /v1/chat/completions с полностью одинаковыми параметрами; достаточно поменять model с grok-4.6 на grok-4.7, остальной код не трогаем:

import requests

resp = requests.post(
    "https://api.hiapi.ai/v1/chat/completions",
    headers={"Authorization": "Bearer $HIAPI_API_KEY"},
    json={
        "model": "grok-4.7",  # 改这里
        "messages": [{"role": "user", "content": "你的任务"}],
    },
)

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

Grok 4.7 дороже 4.6? Дороже не по цене за единицу: в HiAPI оба поколения стоят одинаково — вход $0.84 / выход $2.52 за миллион токенов. Третья сторона traictory.com сообщает, что 4.7 при высоком effort без ограничения тратит около 81K токенов на задачу, примерно вдвое больше, чем 4.6; речь о расходе, а не о цене за единицу. В наших тестах с ограничением max_tokens у 4.7 расход не превысил 4.6.

Какие известные слабые места у 4.7? Часть пользователей в сообществе Cursor сообщает, что 4.7 иногда галлюцинирует, ошибается при слиянии кода и тратит много токенов; некоторые откатились на 4.6. Для простых задач продолжать использовать 4.6 — надёжная замена.

Есть ли различия в контексте и уровнях рассуждения? Нет. У обоих поколений контекст 500K и четыре уровня рассуждения low / medium / high / xhigh, по умолчанию high.

Где можно попробовать сразу? На странице модели Grok 4.7 можно поиграть онлайн; новым пользователям при регистрации дарим 200 кредитов. Подробнее о ценах читайте в статье Цены API Grok 4.7, о подключении — в Руководстве по API Grok 4.7, примеры промптов — в Примерах промптов Grok 4.7; тем, кто всё ещё на старой версии, пригодится страница модели Grok 4.6.