Consider this: Over the past seven days, the number of AI agents deployed on Ethereum mainnet increased by 40%. Yet their aggregated performance on every public benchmark—MMLU, HumanEval, GSM8K—shows zero improvement. Flat. Saturated. The code does not lie, it only reveals. And what it reveals is that the measuring stick itself has broken.
This is not a problem of intelligence stagnation. It is a problem of evaluation entropy. When Scott Wu, CEO of Cognition, stated in a recent interview that “models have saturated every test”, he was not merely reporting a fact. He was declaring the end of an era. An era where public benchmarks acted as the de facto grade for AI capability. An era where any developer could clone a leaderboard and decide which model to integrate. An era of transparent, comparable metrics.
Tracing the assembly logic through the noise, the signal is clear: the industry is pivoting to proprietary evaluation methods. Cognition itself is leading this shift, arguing that what matters is not how a model scores on a static dataset, but how it performs on real-world tasks—specifically, the kind of multi-step, iterative, tool-using tasks that its agent Devin is designed to solve. On the surface, this sounds like a natural progression. But beneath the surface, the architecture of trust is fragile.
Context: The Protocol Mechanics of Evaluation
To understand why this matters for blockchain, we must first parse the current evaluation stack. Public benchmarks act like a shared state layer. They provide a single source of truth that every model builder can query. When a new model claims state-of-the-art on HumanEval, that claim is verifiable by any third party. It is, in effect, a public good—a permissionless oracle of capability.
But every oracle suffers from oracle manipulation. In the world of AI, the manipulation is called “benchmark overfitting.” Models are trained on data that includes the benchmark questions, or are fine-tuned specifically to maximize those scores. The result is a score that does not generalize. The benchmark becomes a test set that is no longer unseen. The entropy of the system increases until the signal-to-noise ratio approaches zero.
Scott Wu’s assertion that every test is saturated is a technical acknowledgment that the oracle has been compromised. The solution, he argues, is to move to proprietary, task-specific evaluation. Cognition will evaluate Devin on internally designed tasks that better reflect real software engineering. The claim is that this provides more useful information to customers. The hidden implication is that it removes the ability for outsiders to audit the results.
Chaining value across incompatible standards. That is what the industry is about to attempt. But the blockchain community knows better than anyone what happens when you standardize on a closed ledger.
Core: Code-Level Analysis and Trade-offs
Let us examine the technical anatomy of a benchmark saturation. Consider the function signature of a typical evaluation pipeline:
evaluate(model, dataset) → {score, confidence_interval}This is a deterministic function. It has no state. It has no memory of previous runs. It assumes that the dataset is a fixed, unbiased sample of the task distribution. When a model is evaluated repeatedly, and the score converges to a ceiling (e.g., 95% on HumanEval), the variance collapses. The function loses discriminative power.
Now consider a proprietary evaluation system. It might look like this:
evaluate(model, {task_generator, environment, validator}) → {pass_rate, task_coverage, failure_modes}Here, task_generator is a stochastic process that creates new tasks on the fly. environment is a sandbox where the agent must operate (e.g., a simulated dev environment with a codebase and CI pipeline). validator checks whether the agent’s output meets success criteria. This system is stateful. It is adaptive. It is designed to resist overfitting because the tasks are never seen twice.
From my audit experience in DeFi—specifically the 2020 composability whitebox audit of Synthetix’s proxy contract—I learned that closed systems can hide reentrancy only until someone finds the entry point. A proprietary evaluation system, no matter how well-designed, is a black box to the outside. The risk is not that Cognition will cheat. The risk is that the evaluation itself becomes a single point of failure. If Cognition’s internal task generator has a blind spot, Devin’s reported performance will be overinflated. And there will be no external oracle to call out the bug.
This is the exact same structural flaw that led to the Terra-Luna collapse. In my 2022 report on that event, I modeled the seigniorage mechanism as a game theoretic equilibrium that depended on a single price oracle. When the oracle broke, the system collapsed. Proprietary evaluation is that oracle for the AI market. If the community accepts it without verification, we are building a house of cards.
But let us be fair. The shift to proprietary evaluation brings genuine benefits. Real-world tasks are inherently multi-modal. An agent that must navigate a codebase, run tests, deploy to staging, and rollback on failure cannot be measured by a multiple-choice test. The evaluation must mirror the complexity of the deployment environment. Cognition’s approach is more aligned with the actual utility that a customer cares about. They are choosing to optimize for what matters, rather than what is easy to measure.
Where logical entropy meets financial velocity. Every AI startup now faces a choice: continue to publish on public leaderboards and risk looking mediocre, or retreat to proprietary evaluation and control the narrative. The market will price this choice accordingly.
The Information Asymmetry Problem
In decentralized finance, information asymmetry is the enemy of fair pricing. The same principle applies to the AI model market. When public benchmarks lose relevance, buyers—whether they are developers integrating an API or enterprises building workflows—lose the ability to horizontally compare models. They must rely on vendor-provided numbers, testimonials, and limited trials.
This is exactly the dynamic we saw in the NFT market during 2021. I argued then that most ERC-721 tokens were not digital assets but receipt tokens, because their metadata was stored off-chain and could be changed. The lack of on-chain integrity created an information asymmetry between sellers and buyers. Today, the evaluation of AI models suffers from the same problem. The metadata (benchmark scores) is becoming unreliable, and the new trusted metadata (proprietary evaluations) is locked inside the issuer’s vault.
Defining value beyond the visual token. In the NFT space, the solution was to enforce on-chain provenance and metadata immutability. For AI evaluation, the equivalent would be to move evaluation onto a blockchain—using smart contracts to administer tasks, verify agent actions, and record results in a tamper-proof ledger. This would create a public, verifiable history of agent performance across many tasks. It would allow for composable evaluation—where different task sets from different providers can be combined into a meta-benchmark. It would also enable economic incentives: agents that perform well on-chain could earn reputation tokens or even direct rewards.
Such a system is not science fiction. The underlying infrastructure exists: L2 execution environments that can run agent logic, oracles that can bridge real-world outcomes, and ZK proofs that can verify computation without revealing the agent’s internal state. The technical challenge is building the task abstraction layer and ensuring that tasks are diverse enough to prevent gaming. But that is a game we have played before—in the DeFi audit space, we built formal verification tools to outrun hackers. We can build on-chain evaluation to outrun overfitting.
Contrarian: The Security Blind Spots of Proprietary Evaluation
Let us assume, for a moment, that every company adopts proprietary evaluation. What are the systemic risks?
First, evaluation as a moat. The companies with the most capital to spend on evaluation infrastructure—setting up elaborate sandbox environments, hiring expert human validators, running thousands of task simulations—will be able to report the most impressive scores. Smaller players, including open-source models, will be relegated to using free public benchmarks that are laughably easy. The result is a tiered market where the cost of entry to the “credible evaluation club” is prohibitive. This is the Layer2 fragmentation problem all over again: dozens of L2s claiming “scaling” but actually just slicing the same small user base. Here, dozens of evaluation frameworks will slice the same small set of verifiable results, leaving users confused and vulnerable to marketing.
Second, the loss of adversarial bench pressing. Public benchmarks allow third parties to attack the model by finding failure cases. The IMO Grand Challenge, for example, was able to surface weaknesses in mathematical reasoning that internal test suites had missed. Proprietary evaluation eliminates this adversarial feedback loop. The model can only fail where the evaluator expects it to fail. Unseen failure modes remain hidden until they manifest in production. This is a security risk of the highest order, especially for code-generating agents like Devin, whose bug can cause real financial damage if deployed on a smart contract.
Third, regulatory vulnerability. If AI evaluation becomes opaque, regulators cannot form independent assessments of whether a model is safe or unbiased. They would have to rely on the same proprietary numbers that vendors provide. The EU AI Act and the US Executive Order both demand transparency. A wholesale shift to proprietary evaluation would be a direct challenge to those regulatory frameworks. Cognition and others may be inadvertently setting the stage for a compliance crisis.
Takeaway: A Vulnerability Forecast
Auditing the space between the blocks. The next major event in this trend will not be a model release—it will be a failure of a proprietary evaluation system that leads to a high-profile model deployment incident. A code agent evaluated solely on internal tasks will produce a bug that costs millions, and the post-mortem will reveal that the evaluation never tested for that specific failure mode. That is the destiny of closed evaluation: it cannot see the edge cases it did not design.
The fix is not to abandon proprietary evaluation, but to make it verifiable. Blockchain offers a path: on-chain evaluation registers that are auditable, composable, and trust-minimized. The first AI company to open-source its evaluation infrastructure as a set of smart contracts—with transparent task generation and result recording—will earn the trust that proprietary evaluation seeks to hoard.
The architecture of trust is fragile. But it can be reinforced with code. The choice is ours: build on a shared state layer of verifiable benchmarks, or continue slicing reality into proprietary slices that no one can see through.
The code does not lie, it only reveals. But if the code is hidden, it can deceive.