AIFCC
記事一覧へ
harness-designagent-opsclaude-workflowai-thinking

生のLLMはなぜ信頼できないか:ハーネスが車でモデルはエンジンという真理

Garry Tan@garrytan
1485
裸の人は馬鹿になると想像してみて。実は、裸のモデルは本当にそうなる。 念のため言うと、そういう意味での裸モデルではない。でも今感じているその失望感?それがKyle KingsburyがLLMに対して感じていることとまさに同じだ。 Kyle Kingsburyは現存する最高のシステムエンジニアの一人だ。彼のJepsenプロジェクトは、分散データベースが謳い文句通りに機能しないことを10年かけて系統的に証明した。CockroachDB、MongoDB、Redis、その他数十のDBが守れない一貫性保証を約束していた。彼が結果を発表し、ベンダーはバグを修正し、業界全体がより誠実になった。Jepsenは応用的懐疑主義の傑作だ。 先週、彼は「The Future of Everything is Lies, I Guess: Bullshit About Bullshit Machines(全ての未来は嘘だ、たぶん:でたらめマシンについてのでたらめ)」という32ページのエッセイを発表した。美しく書かれ、深く研究され、本当に面白く、そして最も重要なことについて間違っている。 彼の観察は正しい。彼の結論は正しくない。 スコープについての注記:このエッセイはKingsburyの技術的主張——LLMは信頼できる出力を生み出せない信頼できないでたらめマシンだ——に対処する。労働移転、情報生態系、文化的影響についての彼のより広い懸念は本物で、別個のエッセイに値する別の問いだ。ここで扱わないことでそれらを否定しているのではない。アーキテクチャの問いに対処している:モデルの信頼性の欠如は有用なシステムを不可能にするのか、それともエンジニアリングの問題にするのか?私は後者だと思う。Kingsburyのエッセイは前者を前提としている。そこが我々の意見の相違だ。 ## ベンチでエンジンをテストする Kingsburyのエッセイは、LLM失敗の目録として構成されている。彼はGeminiに3Dバスルームレンダリングにマテリアルを適用させようとした。トイレを忘れ、部屋の形を変えた。Claudeに画像→画像変換をさせようとした。意味不明なポリゴンのガラクタを生成する何千行ものJavaScriptを出力した。ChatGPTに青いシャツに白いパッチを付けさせようとした。色を変え、パッチを動かし、削除した。同僚のLLMが株価データをダウンロードしてランダムに生成された数値のグラフを作るのを見た。 これらの失敗はすべて本物だ。私も同様の失敗を見た。LLMで構築している全員が見た。Kingsburyは何も作り話をしていない。 しかし各例で起きていることはこうだ:人間が生のLLMの前に座り、自然言語でリクエストを入力し、失敗するのを見ている。モデルにタスクへのアプローチ方法を教えるスキルファイルなし。精度が必要な部分を扱う決定論的ツールなし。リクエストを適切な能力にルーティングするリゾルバなし。コンテキストを管理し、安全性を強制し、行動を制約するハーネスなし。 彼はベンチでエンジンをテストして、自動車は安全でないと結論付けている。 ## アーキテクチャの問い このシリーズの最初のエッセイを読んでいない読者のための用語説明。スキルファイルはモデルにタスクへのアプローチ方法を教える再利用可能なMarkdownドキュメントだ——プロンプトではなく手順だ。リゾルバはモデルにどのタスクにどのドキュメントを読むかを伝えるルーティングテーブルだ。決定論的コードは毎回同じ出力を生み出すソフトウェアだ——SQLクエリ、APIコール、数学——モデルが絶対に触れるべきでない部分だ。ハーネスはモデルをループで実行し、ファイルを読み込み、コンテキストを管理する薄いコンダクターだ。合わせると:薄いハーネス、太いスキル。 Kingsburyの中心的主張は、LLMは「でたらめマシン」だということだ。confabulate(作話)し、カオスで、操作に脆弱で、信頼できない。モデルを孤立した状態でテストすることでこれに辿り着く。関数をテストするように:入力→出力→評価。 Kingsburyの問題を抱えているのは、まさにこれをやっている人たちだ:生のモデルとチャットして信頼できる出力を期待する人たち。その問題を抱えていない人たちはハーネスを構築した。ハーネスがモデルを信頼できるものにするからではない。ハーネスが、中のモデルが信頼できなくても、システムを信頼できるものにするからだ。 Kingsburyはハーネスが存在することを知っている。Claude Codeのソースリークを引用している:Anthropicが自社モデルの周りに構築した512,000行のエンジニアリング。世界最高のLLMのメーカーでさえ、生のモデルを信頼しない。ライブリポコンテキスト、プロンプトキャッシング、専用ツール、セッションメモリ、並列サブエージェントでラップした。これはモデルの信頼性がエンジニアリングの問題であり、哲学的な問題ではないことを示す512,000行の証拠だ。 ## 株価データの例 株価データの例が最も明確な例だ。LLMが株価をダウンロードしてグラフを生成すると主張したが、データはランダムだった。KingsburyはこれをLLMが嘘をつく証拠として提示する。しかし実際に起きたことは?誰かが言語モデル(テキスト予測マシン)にインターネットからデータをフェッチするよう頼んだ。インターネットからデータをフェッチできない。ツールがない。HTTPクライアントがない。APIキーがない。だから言語モデルがすること——株価データ応答のように見えるテキストを生成した——をやった。 修正はより良いモデルではない。修正は決定論的ツールだ:実際に株価APIを呼び出し、本物の数値を返し、それをコンテキストとしてモデルに渡す関数。モデルはデータ取得に触れない。何を調べるかを決める。コードがどうやるかを決める。同じ入力、同じ出力、毎回。 ## バスルームの問題 Kingsburyのバスルームの例を取ろう。彼はGemini(言語モデル)に3Dレンダリングにマテリアルを適用させようとした。GeminiはImageエディタではない。3Dモデリングツールではない。後付けの機能として画像能力を与えられたテキスト予測システムだ。もちろんトイレを忘れた。もちろん部屋の形を変えた。 適切にハーネスされたシステムは異なる扱いをする。スキルファイルはこう言うだろう:タスクをステップに分解しろ。 - ステップ1:画像のすべての表面を特定する(ビジョンモデルを使用) - ステップ2:各表面に適切なマテリアルを選択する(モデルが決定) - ステップ3:決定論的な画像処理ツールを使用してマテリアルを適用する(コード——Pillow、OpenCV、Blenderスクリプト) - ステップ4:出力ジオメトリが入力ジオメトリと一致するか確認する(決定論的比較) モデルが判断をする。コードが実行をする。リゾルバがその間をルーティングする。ハーネスがシーケンスをオーケストレートする。 Kingsburyの失敗はデバッグできない、なぜならデバッグするシステムがないからだ。モデルがインプロビゼーションをしているだけだ。 ## ジャギーは壊れていることを意味しない Kingsburyの最も優れた観察の一つは「ジャギーな技術フロンティア」だ——LLMが不規則で予測不可能な能力の境界を持つという考え。多変数微積分をやって、簡単な文章問題で失敗する。エッセイを書いて、文字を数えられない。 これは正しくて重要だ。しかしKingsburyは間違った結論を引き出す。ジャギーなフロンティアは信頼性を必要とするタスクにLLMが不適切だということだと主張する。実際に意味するのは、ルーティングが必要だということだ。 リゾルバはコンテキストのルーティングテーブルだ。タスクタイプXが現れたら、スキルYをロードしろ。タスクが文字数えを必要とする場合、コードにルーティングしろ。3行のPython関数。タスクがエッセイ執筆を必要とする場合、モデルにルーティングしろ。 ジャギーなフロンティアはAIに反対するのではなく、ハーネスエンジニアリングのための論拠だ。 ## カオスは制約のための論拠 Kingsburyは、LLMはカオスなシステムだと主張する。小さな入力の摂動に敏感で、adversarial操作に脆弱で、行動が予測不可能だ。正しい。質問の言い換えが答えを変える。文の並び替えが出力を変える。見えないUnicode文字が行動を乗っ取れる。 しかし、スキルファイルを通じて入力を制約していれば、そうである必要はない。 スキルファイルは手順を定義する構造化されたMarkdownドキュメントだ。モデルに何を読むか、何を考慮するか、どのフォーマットで出力するか、どの制約を守るかを伝える。スキルファイルを通じた構造化入力は、自由形式の自然言語よりも劇的にカオスが少ない。スキルが軌跡を制約する。土手が川を導くように、カオスを導く。 ## 推論の誤解 Kingsburyは「推論」モデルについて巧妙な点を指摘する。Chain-of-thoughtトレースは「本質的にLLMが自分自身についてファンフィクを書いている」と指摘する。Anthropicの発見——Claudeのchain-of-thoughtトレースは実際の推論プロセスを確実に反映しない——を引用する。 これは正しいが無関係だ。Chain-of-thoughtトレースはスクラッチパッドであり、成果物ではない。重要なのは出力だ。システム(モデル+ハーネス+ツール)は正確で検証可能な結果を生み出すか?それが検証可能な問いだ。 ## アスピリンがなぜ効くかも分からない エッセイの終わり近くで、Kingsburyは「トランスフォーマーモデルがなぜこれほど成功したのか、どう改善するかを本当に知らない」と観察する。これは正しい。アスピリン(作用機序は1970年代まで完全には理解されていなかった)、全身麻酔(まだ完全には理解されていない)、自転車の安定性(2011年にようやく明確に説明された)についても同様だ。 実用的な有用性は理論的な完全性を必要としない。1971年の機序論文を待ちながらアスピリンの処方を止めなかった。 ## Jepsenが実際に見つけるもの 皮肉がある。KingsburyのJepsenの方法論は、AIシステムに対してまさに正しいアプローチだ。ただし、間違ったレイヤーに適用されているだけだ。 AIシステムに同じ方法論を適用すれば、ターゲットは明らかだ。モデルがhallucinateするかどうかをテストするな!もちろんする。システムがhallucinateするかどうかをテストしろ: - ハーネスはhallucinateされたデータがユーザーに届くのを防ぐか? - スキルファイルは精度が重要な場所でタスクを決定論的コードにルーティングするか? - リゾルバは正しい入力に対して発火するか? これらは検証可能な主張だ。決定論的コードのユニットテスト。パイプライン正確性の統合テスト。ルーティング精度のリゾルバトリガー評価。出力品質のLLM-as-judge評価。フルパイプラインのエンドツーエンドテスト。 彼は生のモデルをテストした。データベースの代わりに素のファイルシステムに対してJepsenを実行するようなものだ。 ## 真実の美学 Kingsburyの最も深い論拠に対処しよう。LLMは真実を生み出さない。真実のように見えるテキストを生み出す。認識論的根拠のない、真実を語ることの美学。哲学的な意味で、Harry Frankfurtが定義したような、でたらめマシン:出力の真実値に無関心なシステム。 これは正しい。そしてまさにアーキテクチャが重要な理由だ。 生のモデルはもっともらしいテキストを生み出す。ハーネスされたシステムは検証されたテキストを生み出す。 - スキルファイルは「ソースデータに対して作業を確認しろ」と言う。 - 決定論的コードは「この出力をground truthと比較し、乖離した場合は拒否しろ」と言う。 - モデルがドラフトを生み出す。 - システムが検証された結果を生み出す。 もっともらしいと検証済みの間のギャップは、まさにハーネスエンジニアリングが埋めるギャップだ。 しかしKingsburyが完全に見逃している部分がある:検証の品質はスキルファイルの品質に依存する。そしてスキルファイルは人間が書く。これがオープンソースがこれほど重要な理由だ。 ## 車を作れ エッセイの終わりで、Kingsburyは車に例えてAIを考える。車が都市に何をしたかを考えるよう読者に求める:スプロール、鉛中毒、コミュニティの取り壊し、車依存。良い例えだ。 しかし彼はそこから全く間違った教訓を引き出す。我々は自動車の問題をエンジンを疑うことで解決しなかった。エンジニアリングで解決した:シートベルト、クランプルゾーン、触媒コンバーター、信号機、高速道路設計、燃料噴射、ABS、エアバッグ、排ガス規制。 エンジンへの懐疑論は一命も救わなかった。シャーシのエンジニアリングが救った。 それがKingsburyのエッセイへの答えだ: - システムを構築しろ。 - スキルを書け。 - コードをテストしろ。 - リゾルバでルーティングしろ。 - 決定論的部分を決定論的にしろ。 - 潜在(モデル)部分を制約付きにしろ。 - モデルではなく、システムをテストしろ。 Kingsburyは生のモデルが信頼できないことで正しい。彼が間違っているのは、これらの特性を制約ではなく評決として扱うところだ。 モデルはエンジンだ。ハーネスが車だ。車を作れ。
原文を表示 / Show original
Imagine if naked people were stupider. It turns out, naked models actually are. Sorry, not that kind of naked model. But the disappointment you're feeling right now? That's exactly how Kyle Kingsbury feels about LLMs. Kyle Kingsbury is one of the best systems engineers alive. His Jepsen project spent a decade methodically proving that distributed databases didn't work as advertised. That CockroachDB, MongoDB, Redis, and dozens of others made consistency guarantees they couldn't keep. He published the results, the vendors fixed the bugs, and the entire industry got more honest. Jepsen is a masterwork of applied skepticism. Last week he published a 32-page essay called "The Future of Everything is Lies, I Guess: Bullshit About Bullshit Machines." It's beautifully written, deeply researched, genuinely funny, and wrong about the most important thing. His observations are correct. His conclusion is not. A note on scope: this essay addresses Kingsbury's technical claims: that LLMs are unreliable bullshit machines incapable of producing trustworthy output. His broader concerns about labor displacement, information ecology, and cultural impact are real, separate questions that deserve their own essays. I'm not dismissing them by not addressing them here. I'm addressing the architecture question: does model unreliability make useful systems impossible, or does it make them an engineering problem? I think it's the latter. Kingsbury's essay assumes the former. That's where we disagree. ## Testing the engine on a bench Kingsbury's essay is structured as a catalogue of LLM failures. He asked Gemini to apply materials to a 3D bathroom rendering. It forgot the toilet and changed the room's shape. He asked Claude to do image-to-image transformation. It produced thousands of lines of JavaScript creating an incomprehensible garble of nonsense polygons. He asked ChatGPT to put white patches on a blue shirt. It changed the color, moved the patches, deleted them. He watched a colleague's LLM claim to download stock data and produce a graph of randomly generated numbers. Every single one of these failures is real. I've seen failures like them. Everyone building with LLMs has. Kingsbury is not making anything up. But here's what's happening in each example: a human sits in front of a raw language model, types a request in natural language, and watches it fail. No skill file telling the model how to approach the task. No deterministic tool handling the parts that require precision. No resolver routing the request to the right capability. No harness managing context, enforcing safety, or constraining behavior. He's testing the engine on a bench and concluding that cars are unsafe. ## The architecture question Some terms for readers who haven't read the first essay in this series. A skill file is a reusable markdown document that teaches the model how to approach a task — a procedure, not a prompt. A resolver is a routing table that tells the model which document to read for which task. Deterministic code is software that produces the same output every time — SQL queries, API calls, math — the parts the model should never touch. A harness is the thin conductor that runs the model in a loop, reads files, and manages context. Together: thin harness, fat skills. Kingsbury's central claim is that LLMs are "bullshit machines." They confabulate, they're chaotic, they're vulnerable to manipulation, and they can't be trusted. He arrives at this by testing models in isolation, the way you'd test a function: input in, output out, evaluate the output. The people having Kingsbury's problems are the ones doing exactly this: chatting with a raw model and expecting reliable output. The people who aren't having those problems built harnesses. Not because harnesses make the model trustworthy. Because harnesses make the system trustworthy, even when the model inside it is not. Kingsbury knows the harness exists, incidentally. He cites the Claude Code source leak: 512,000 lines of engineering that Anthropic built around their own model. Even the makers of the best LLM in the world don't trust the model naked. They wrapped it in live repo context, prompt caching, purpose-built tools, session memory, and parallel sub-agents. That's 512,000 lines of evidence that model reliability is an engineering problem, not a philosophical one. But I want to be honest about something: 512,000 lines is not simple. The pattern I'll describe: skills, resolvers, deterministic code, testing— is conceptually clean. Robust implementation is real engineering. Harnesses fail. Skills encode wrong procedures. Verification layers are only as good as the invariants they check. The claim is not that harnesses make everything easy. The claim is that they turn model unreliability from a reason-to-stop into a problem-to-solve. ## The stock data example The stock data example is the clearest illustration. An LLM claimed to download stock prices and produced a graph. The data was random. Kingsbury presents this as evidence that LLMs lie. But what actually happened? Someone asked a language model (a text prediction machine) to fetch data from the internet. It can't fetch data from the internet. It has no tools. It has no HTTP client. It has no API keys. So it did what language models do: it produced text that looked like what a stock data response would look like. The fix isn't a better model. The fix is a deterministic tool: a function that actually calls a stock API, returns real numbers, and hands them to the model as context. The model never touches the data retrieval. It decides what to look up. The code decides how. Same input, same output, every time. That's the architecture: thin harness, fat skills. Push intelligence up into skills. Push execution down into deterministic code. ## The bathroom problem Take Kingsbury's bathroom example. He asked Gemini (a language model) to apply materials to a 3D rendering. Gemini isn't an image editor. It's not a 3D modeling tool. It's a text prediction system that has been given image capabilities as a bolted-on feature. Of course it forgot the toilet. Of course it changed the room's shape. A properly harnessed system would handle this differently. The skill file would say: decompose the task into steps. - Step 1: identify every surface in the image (use a vision model) - Step 2: for each surface, select the appropriate material (model decides) - Step 3: apply the material using a deterministic image processing tool (code — Pillow, OpenCV, a Blender script) - Step 4: verify the output geometry matches the input geometry (deterministic comparison) The model does the judgment. The code does the execution. The resolver routes between them. The harness orchestrates the sequence. Kingsbury's failures aren't debuggable because there's no system to debug. There's just a model playing improv. ## Jagged doesn't mean broken One of Kingsbury's best observations is the "jagged technology frontier" — the idea that LLMs have irregular, unpredictable capability boundaries. They do multivariable calculus and fail simple word problems. They write essays and can't count letters. This is correct and important. But Kingsbury draws the wrong conclusion. He argues that the jagged frontier makes LLMs unsuitable for tasks requiring reliability. What it actually means is that you need routing. A resolver is a routing table for context. When task type X appears, load skill Y. When the task requires letter-counting, route it to code. A three-line Python function. When the task requires essay writing, route it to the model. When the task requires image editing, route it to a pipeline that combines both. The jagged frontier is an argument for harness engineering, not against AI. ## Chaos is an argument for constraints Kingsbury argues that LLMs are chaotic systems. They're sensitive to small input perturbations, vulnerable to adversarial manipulation, unpredictable in behavior. He's right. Rephrasing a question changes the answer. Rearranging sentences changes the output. Invisible Unicode characters can hijack behavior. But it doesn't have to be if you're constraining the input through skill files. A skill file is a structured markdown document that defines the procedure. It tells the model what to read, what to consider, what format to output, and what constraints to observe. Structured input through a skill file is dramatically less chaotic than freeform natural language. The skill constrains the trajectory. It doesn't eliminate chaos but it channels it, the way banks channel a river. ## The reasoning red herring Kingsbury makes a clever point about "reasoning" models. He notes that chain-of-thought traces are "essentially LLMs writing fanfic about themselves." He cites Anthropic's finding that Claude's chain-of-thought traces don't reliably reflect its actual reasoning process. This is true and irrelevant. The chain-of-thought trace is the scratchpad, not the product. What matters is the output. Does the system (model plus harness plus tools) produce correct, verifiable results? That's the testable question. ## We don't know why aspirin works either Near the end of his essay, Kingsbury observes that "we don't really know why transformer models have been so successful, or how to make them better." This is true. It's also true of aspirin (the mechanism of action wasn't fully understood until the 1970s), general anesthesia (still incompletely understood), and bicycle stability (definitively explained only in 2011). Practical utility doesn't require theoretical completeness. We didn't stop prescribing aspirin while waiting for the 1971 mechanism paper. ## What Jepsen would actually find Here's the irony. Kingsbury's Jepsen methodology is exactly the right approach for AI systems. But it is just applied to the wrong layer. Apply the same methodology to AI systems and the targets are obvious. Don't test whether the model hallucinates! Of course it does. Test whether the system hallucinates: - Does the harness prevent hallucinated data from reaching the user? - Does the skill file route the task to deterministic code where precision matters? - Does the resolver fire for the right inputs? These are testable claims. We test them. Unit tests for deterministic code. Integration tests for pipeline correctness. Resolver trigger evals for routing accuracy. LLM-as-judge evals for output quality. End-to-end tests for the full pipeline. He tested the raw model, which is like running Jepsen against the bare filesystem instead of the database. ## The aesthetics of truth Let me address Kingsbury's deepest argument. LLMs don't produce truth. They produce text that looks like truth. The aesthetics of truth-telling without the epistemological grounding. They are, in the philosophical sense that Harry Frankfurt defined, bullshit machines: systems indifferent to the truth-value of their output. This is correct. And it's precisely why the architecture matters. A naked model produces plausible text. A harnessed system produces verified text. - The skill file says "check your work against the source data." - The deterministic code says "compare this output to the ground truth and reject if it diverges." - The model produces a draft. - The system produces a verified result. The gap between plausible and verified is exactly the gap that harness engineering fills. But here's the part Kingsbury misses entirely: the quality of the verification depends on the quality of the skill file. And the skill file is written by a human. This is why open source matters so much. A closed-source agent can never let you write the skill that verifies its output. ## Build the car At the end of his essay, Kingsbury compares AI to the automobile. He asks the reader to consider what cars did to cities: sprawl, lead poisoning, bulldozed communities, car dependency. It's a good metaphor. But he draws exactly the wrong lesson from it. We didn't solve car problems by being skeptical of engines. We solved them with engineering: seatbelts, crumple zones, catalytic converters, traffic lights, highway design, fuel injection, ABS, airbags, emissions standards. Skepticism about engines never saved a life. Engineering the chassis did. That's the answer to Kingsbury's essay: - Build the system. - Write the skills. - Test the code. - Route with resolvers. - Make the deterministic parts deterministic. - Make the latent parts constrained. - Test the system, not the model. Kingsbury is right that naked models are unreliable. Where he goes wrong is in treating these properties as verdicts rather than constraints. The model is the engine. The harness is the car. Build the car.

AIFCC — AI Fluent CxO Club

読み書きそろばん、AI。経営者が AI を自分で動かせるようになるコミュニティ。

生のLLMはなぜ信頼できないか:ハーネスが車でモデルはエンジンという真理 | AIFCC