Grok 4.7 vs Grok 4.6：同価格・同コンテキスト、違いはどこで、どう選ぶか

TL;DR：複雑なコーディングや agentic タスクでは Grok 4.7、軽量タスクで token を節約したいなら Grok 4.6 を選ぶ。両世代は HiAPI で完全に同価格（入力 $0.84 / 出力 $2.52 每百万 token）、同 500K コンテキストで、唯一の決め手はタスクの種類だ。Grok 4.7 は HiAPI で提供開始済み。モデルページを開くとすぐに試せて、新規ユーザー登録で 200 ポイントがもらえる。

ひと目でわかる：両世代の違い

項目	Grok 4.7	Grok 4.6
プラットフォーム価格（每百万 token、入力/出力）	$0.84 / $2.52	$0.84 / $2.52（同価格）
コンテキスト	500K	500K
コーディング能力（Terminal-Bench 4.0、公式自己申告）	38.0%	20.3%
位置づけ	公式のデフォルト推奨、コーディングと agentic タスクが主軸	前世代のフラッグシップ、販売中
token 消費量（第三者 traictory.com、高 effort・上限なし）	約 81K/タスク、ほぼ 4.6 の 2 倍	より少ない
推論レベル	low / medium / high / xhigh、デフォルトは high	同じ
知識カットオフ	2026-05	より早い

価格、コンテキスト、推論レベルは完全に同じで、本当の分かれ目はコーディング能力と出力の傾向だ。以下では 2 組の同一プロンプト実測で説明する。

同一プロンプト（1）：LRU キャッシュのコーディング問題

2026-10-29 に HiAPI 本番環境で実測。両者とも同パラメータ（推論レベルはデフォルトの high、max_tokens に上限あり）で各 1 回実行：

プロンプト：

Python の LRU キャッシュクラスを書いてください。get と put は O(1)、TTL 対応（期限切れで自動失効）、スレッドセーフであること。コードと 5 行以内の使用説明だけを出力してください。

Grok 4.7 の回答（39.7s、出力 3285 token、約 $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)

（全文には import と使用例を含む。以上が本文の主要部分。4.7 は time.monotonic() で TTL を計測し、get にデフォルト値を渡せる。）

Grok 4.6 の回答（61.9s、出力 3915 token、約 $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
所要時間 / 出力 token	8.3s / 573	18.5s / 637
答え	24 時間	24 時間

両方とも LaTeX で 1/6 − 1/8 = 1/24 → 1 ÷ 1/24 = 24 の完全な過程を書き、結論と導出は等価だった。

目に見える違い

• コーディング問題では 4.7 が 22 秒速く（39.7s vs 61.9s）、出力はむしろ短い（3285 vs 3915 token）
• 推論問題は両方とも正解で、過程も等価
• 出力の傾向として 4.7 は構造化見出しと LaTeX 式を好み、文章がより簡潔。4.6 も LaTeX を使うがやや冗長（637 vs 573 token）
• 今回の capped 実測（max_tokens に上限あり）では、4.7 の出力 token は 4.6 より多くなかった。第三者 traictory.com の「1 タスクあたり約 81K token、4.6 の約 2 倍」は高 effort・上限なしの基準であり、2 組のデータは矛盾せず、混用すべきでもない
• 公式自己申告の Terminal-Bench 4.0 は 20.3% から 38.0% に向上しており、上記コーディング問題の体感方向と一致する
• この 2 組の比較と別の 5 シナリオ実走（トラブルシューティング、コードレビュー、設計など）の計 9 リクエストはすべて正常終了（finish=stop）し、切断はなかった

シナリオ別の選び方

• 複雑なコーディングや長時間の agentic タスクには Grok 4.7
• 日常的な軽量 Q&A、フォーマット変換、簡単なスクリプトには Grok 4.6。出力は劣らず token も節約
• すでに 4.6 を安定運用中なら無理に移行しなくてよい。新タスクはまず 4.7 で試し、不満ならいつでも戻せる
• 予算重視で 4.7 の能力も欲しい場合：両世代は同価格で、差は消費量。軽量タスクに 4.6 を使えば節約になる

切り替えコスト：変更するのは 1 フィールドだけ

両世代は同じ /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 每百万 token。第三者 traictory.com は 4.7 が高 effort・上限なしの条件で 1 タスクあたり約 81K token、4.6 の約 2 倍と報告しているが、これは消費量を指し単価ではない。私たちの max_tokens 上限ありの実測では 4.7 は 4.6 より多くなかった。

4.7 に既知の弱点はありますか？ Cursor コミュニティでは一部ユーザーが 4.7 の偶発的なハルシネーション、コードマージの誤り、token 消費の多さを報告し、4.6 に戻す人もいる。簡単なタスクでは 4.6 を使い続けるのが堅実な代替だ。

コンテキストや推論レベルに違いはありますか？ ない。両世代とも 500K コンテキスト、low / medium / high / xhigh の 4 段階推論で、デフォルトは high。

どこで直接試せますか？ Grok 4.7 モデルページでオンライン試用でき、新規ユーザー登録で 200 ポイントがもらえる。価格の詳細は Grok 4.7 API 価格、導入方法は Grok 4.7 API ガイド、シナリオ別プロンプトは Grok 4.7 プロンプト例を参照。旧版を使い続けている場合は Grok 4.6 モデルページと比較できる。