Torygreen

Most people are massively underestimating how long high-end knowledge work will survive.
They’re extrapolating from AI crushing mid-level tasks and assuming the curve continues smoothly upward.
It won’t.
AI is incredible at:
• Pattern matching
• Retrieval
• First-order synthesis
• Fluency
• Speed
That wipes out huge swaths of junior and mid-tier knowledge work.
But elite knowledge work isn’t just “more intelligence.” It’s a different regime entirely.
What actually matters at the top:
• Choosing the right problem
• Framing when the objective function is unclear
• Reasoning under ambiguity and i

Most forecasts about AI replacing "all knowledge work" hinge on a simple extrapolation error:
They confuse task performance with judgment.
People see AI demolish mid-level tasks and assume the curve continues smoothly upward.
But the top of knowledge work isn’t a harder version of the middle. It’s a different regime entirely.
When the job stops being “solve the problem” and becomes “pick the right problem,” the rules flip.
Models get better at tasks with a scoreboard.
Judgment is choosing the scoreboard, and paying for misses.

Most people underestimate how long high-end knowledge work will survive.
They see AI crushing mid-level tasks and assume the curve continues smoothly upward.
It won’t.
Because “harder tasks” aren’t just the same tasks that need more IQ.
AI is already elite at:
1. Pattern matching
2. Retrieval
3. First-order synthesis
4. Fluency
5. Speed
That wipes out huge swaths of junior and mid-tier work.
Anything that looks like “turn inputs into outputs” becomes cheap, fast, and abundant.
But elite knowledge work operates in a different regime.
It’s not “produce the answer.”
It's “decide what to do next.”

You won’t lose your job to AI first.
You’ll lose it because of mass overconfidence.
AI will let millions ship fluent answers without owning the consequences.
The first AI casualties won’t be workers.
They’ll be institutions that mistake output volume for truth.

A model isn't a moat.
Intelligence is easy to replicate.
You can download weights, fork architectures, and fine-tune forever.
But you can’t deploy that intelligence at scale if someone else controls inference: pricing, quotas, KYC, regions, and policy switches that change overnight.
As AI moves from chatbots to agents, that gate becomes the choke point.
Who can run, when, at what latency, on which hardware, under whose rules.... and what happens when you get throttled from 200ms to 2 seconds.
Models will keep improving.
Rails decide which models find users.
Whoever controls inference access do

The most valuable AI company in ten years won’t be the one with the smartest model.
It will be the one every other model depends on to run.
Models commoditize fast - they don't stay special for long. Architectures leak. Training tricks spread. The “best model” stops being a lasting edge.
Infrastructure problems are different from model problems.
Latency, throughput, uptime, verification. Those are physical and economic constraints, not problems you solve by publishing another paper.
As AI becomes agentic, value shifts from who trained the model → who can run it at scale, reliably, and verifiab

Your AI is gaslighting you into being incompetent.
One of the least discussed risks of compliant AI isn’t misinformation.
It’s miscalibration.
Systems designed to be endlessly agreeable don’t just shape answers. They shape users, training people to mistake fluency for competence.
I notice this in myself, which is why I encourage my models to become sparring partners. When the system is smooth and affirming, it’s easy to move faster without being tested. You feel capable because nothing has really pushed back.
In the real world, competence is built through friction.
You’re wrong.
Someone correc

The DePIN & GPU narrative persists because constraints haven't moved.
Demand for training and inference keeps compounding, while centralized clouds stay bottlenecked by CAPEX, geography, and queuing.
Sure, a few years ago, compute scarcity was still a theory.
But now it’s an operational constraint.
How does this affect the usage and revenue of decentralized compute networks?
Decentralized compute networks aren’t “waiting for utilization someday.” They’re already running production workloads for real customers, under real latency constraints.
Tokenized GPUs, on-demand clusters, and hybrid cloud

DeFAI has a credibility problem.
The moment your AI agent thinks off-chain, DeFAI stops being verifiable because you’ve inserted a trust gap into an otherwise transparent on-chain workflow.
That gap?
A new shared dependency.
Every protocol that relies on that off-chain agent is forced to trust it, then pass that black box down the stack.
The fix is receipts: cryptographic evidence.
What do DeFAI protocols need to prove, end-to-end and transparently, so anyone can verify?
What data the agent saw.
What model and version it ran.
What constraints it was bound by.
What action it took.
What outcome

Think of it like layers:
The Internet = information commons
Crypto = financial commons
DeAI = cognitive commons
Together, they become a shared mind.
Open by default.
Checkable by code.
Owned by no one.
DeAI is the missing layer that translates crypto for the rest of the world.

> be openAI, 2025
> "we respect your privacy"
> "we don’t collect your facts about your life, we just improve the model for everyone"
> you: sounds wholesome, here’s my entire childhood history for $20/mo
> roll out "Memory"
> "long-term personalization," they say, "so you don’t have to repeat yourself"
> we now remember your job, ex, macros, and that one weird fear you told us at 3am
> next patch: Pulse
> we quietly plug into your calendar, news prefs, and “connected apps”
> wake up to personalized life briefings curated by the thing that watched you spiral for a year
> still "no plans for ad

The current GPU shortage is not a temporary logistical problem.
It is a structural failure of centralization.
Supply relies on a single-node supply chain.
Demand for AI inference is infinitely scalable.
Decentralized compute is the only thing that can relieve the pressure.

one angle worth highlighting: memory shifts agents from "prompt responders" to stateful systems. once state exists, you get compounding behavior, which is exactly why the jump from tools to agents feels so dramatic.

Most of the new demand for compute is quietly shifting from people to AI agents.
Robotics teams run thousands of virtual bots through factories and warehouses before a single physical deployment.
Gaming studios simulate NPCs with long-term memory and coordination instead of scripted bots.
All of this wants cheap, elastic simulation cycles, which is where DeAI clouds show up with distributed GPUs.
Humanoids in factories or workplace agents inside enterprises are just the visible surface.
What matters is the loop beneath them: simulation, deployment, feedback, retraining, repeat… until the grid

> Crypto for the Few (2021):
You manually bounced between protocols, trying to squeeze out a few extra points of yield.
> Crypto for Everyone (2025):
You set one intent and let a network of agents handle the entire sequence: "Maximize risk-adjusted stablecoin yield."
Humans define direction.
AI executes with precision.
Crypto finds its PMF when people don’t have to think about it... when intents route through open, permissionless rails automatically.

Robotics is the largest hidden buyer of GPU cycles.
Every physical robot needs thousands of virtual tests running in parallel.
If these simulations run on centralized clouds, the architecture inherits:
> High latency
> Vendor lock-in
> Systemic fragility
Simulations must run at the periphery, where the data is generated... or we accept that a handful of clouds will effectively puppet every robot that moves.

DeFi isn’t “going to” get agents.
They’re already routing volume on open rails.
Scanning pools.
Rebalancing across chains.
Farming stables while you sleep.
The next wallet isn’t an app.
It’s an intent layer plugged into a credibly neutral swarm of verifiable agents.

2026 will be agent-native, not app-native.
Agents will own wallets, talk to each other over open standards for intents, proofs, and payments, and rent compute directly from DeAI protocols.
Humans move up the stack from clicking buttons to setting risk limits and rules for autonomous agents.