Every GP I’ve pitched has a similar line ready when an LP asks. I’m not sure any of us actually knows.

So I built a tool to find out. It’s called the Power Law Lab, and it runs 10,000 simulated versions of a fund you describe.

The histogram shows the full distribution of plausible outcomes and not just the headline number.

→ canonical.cc/labs/power-law

What we noticed

Venture returns are power-law shaped. A handful of investments produce nearly all the returns. Every GP knows this. Every LP nods.

But that’s usually where it stops. We don’t internalize the consequences. When I write “we’re targeting a 3x net TVPI” in a deck, what’s behind that number? Is it the mean across plausible outcomes? The median? The top quartile? I’d be lying if I said I had a precise answer.

The mean and the median are not the same thing. In a power-law distribution, the mean is dragged up by rare right-tail outliers. The median is much lower. A “2x fund” by mean might be a 1.2x fund by median, with one Uber-shaped outlier doing all the work. The deck quotes the mean because that’s the flattering number.

What this actually does

Describe a fund its size, the number of investments, the failure rate, the shape of the right tail, your reserves strategy, your ownership target. The lab runs 10,000 simulated versions of that fund and renders the distribution.

The math is a mixture model: each company either returns zero (with some loss probability) or draws an outcome multiple from a truncated Pareto distribution. The shape parameter α controls how fat the tail is, and α turns out to be the most consequential slider in the lab.

Calibration follows public empirical work from Correlation Ventures, Kauffman, Carta and AngelList. The Seed preset assumes a 50% loss rate, α=1.2, cap at 500x. Series A and Growth presets get progressively thinner tails.

I vibe-coded the first version over a weekend. ~800 lines of JavaScript. Runs in your browser. No server.

3 things the lab taught me about our fund

1. More investments doesn’t help you.

Expected fund TVPI is invariant to the number of investments if you hold the strategy constant. Going from N=15 to N=50 doesn’t move the mean. It collapses the variance. That feels safer, but LPs aren’t paying us for the median. They are paying for exposure to the right tail. Indexing the power law squeezes that out of your own portfolio.

2. Follow-on discipline moves more than anything else.

Switching from pro-rata across the portfolio to super pro-rata into winners moves median TVPI more than any other parameter I tested. More than fund size, check ownership, or tail thickness. Reserves aren’t a hedge. They’re a second swing at the same pitch. We had been pro-rata-ing out of optionality and reputation. The math doesn’t support that choice as strongly as I’d assumed.

3. The median fund is boring.

Even with realistic seed-stage parameters, the median simulated fund returns roughly 1.3x net. The point isn’t that venture math is hopeless. It’s that the median is the natural outcome, and the funds distribution is itself power-law shaped. You can’t average your way into the tail.

What this actually means

Most GPs cannot tell you where their current TVPI sits in the distribution of plausible outcomes for their strategy. I couldn’t, before I built this. The pitch deck quotes the mean because that’s the number that flatters us most.

For LPs, the lab gives you a way to plug in a manager’s stated strategy and stress-test their projections. If their 3x target sits in the top decile of plausible outcomes for their setup, you should know that before the IC meeting.

For GPs, it’s an honest conversation with yourself. Where are you in the distribution? What would have to be true for the next-quarter mark to move you up?

Try it

→ canonical.cc/labs/power-law

3 calibrated presets, 6 scripted scenarios. Each scenario isolates a single counter-intuitive thing the math does that pitch decks gloss over. Start with the N debate scenario.

Every parameter gets encoded in the URL hash, so you can send a colleague the exact configuration you’re looking at.

If you find something useful or something you disagree with I’d love to hear it. The model has deliberate simplifications worth poking at: independent company outcomes, no time-value modeling.

We are going to keep building things like this!

Luna does almost everything. She sourced the products, negotiated with suppliers, set the prices, hired the painters for the mural, and ran the phone interviews to hire the two human employees who actually run the floor.

Why does she need them? Because general-purpose robotics isn’t quite there yet.

The gap is hands

Luna can hire, price, source, negotiate, and schedule. What she cannot do is restock a shelf, sweep a floor, or take a delivery off a truck. The cognitive layer of running a physical business is roughly solved. The physical layer is not.

Now imagine the next version of that store. Luna is still the brain, but instead of human employees, affordable robotic arms handle the physical labor. Frontier labs are racing the cost of the cognitive model toward zero. The bottleneck moves entirely to hardware, who can put a reliable, deployable arm next to that digital brain.

Multiply that pattern across every packing line, logistics bay, and commercial back-of-house in the country. You’re staring at a global labor-spend pool that dwarfs SaaS by roughly 30x.

That’s the wedge our portfolio company Robo is going after.

Why this time is actually different

2 things have shifted under the surface:

1. Scaling laws hold in robotics: More tele-operation hours in, lower model loss out. Fleets backed by remote operators are doing economically real work today, allowing startups to deploy immediately and ramp human intervention down as autonomy goes up.

2. The macro stakes are higher: The hurdles are real. Most manipulation models sit in the 80–90% success range, and the US infrastructure layer is paper thin. China installed roughly 295K industrial robots last year. The US installed about 34K. That 10x supply gap is a strategic vulnerability. Because hardware is brutally hard to scale, most robotics startups die in the supply chain.

Where Robo fits

Robo builds affordable robotic arms designed so the arms can eventually build more of themselves (see our earlier post about Robotic Superintelligence) to force down unit economics. They run a dual GTM on identical hardware:

• They sell arms ($2,500/unit): The lowest cost in the category for this payload-to-precision ratio. AI labs buy them for mass data collection; developers buy them to build on. To accelerate adoption, the low-level stack is open-source.

• They deploy arms (Robot-as-a-Service): They walk into high-volume industrial lines (like food packing), set up the hardware, and provide end-to-end tele-op coverage. Customers pay by the hour with zero CapEx. When the model stumbles, a remote human takes over instantly so the line never stops.

This dual motion creates a closed data flywheel. They own both ends: the labs training the models, and the physical floors where those models accumulate real-world hours.

Velocity

In January, the company was just a pegboard, two arms, and simulation software.

5 months later, they have redesigned the arms with a domestic sheet-metal core, scaled an in-house print farm for outer shells, secured ~100 preorders, and gone live with their first deployment.

Crucially, their domestic architecture is engineered to transition into sealed, cleanroom-ready variants. A US-built arm capable of meeting strict pharma and medical specs avoids the shifting regulatory hurdles that plague Chinese-manufactured alternatives.

What I come back to

There’s a version of this company that tried to do humanoids, or build a foundation model, or sell pure software. Instead, they picked the most boring-sounding piece of the stack - affordable hardware and deployment infrastructure, and executed with unusual clarity.

Luna at Andon Market can run a store, but she cannot yet stock her own shelves. Someone has to build the arm that does that, in volume, for a price a corner-store economic model can absorb.

Reach out to Robo if you need some US-homegrown robotic arms that are quick and cost-effective.

How much does this SAFE actually cost us? What if we stack another at a higher cap? How much do we lose if we top up the option pool to 15% at the Series A? At a $1B exit, what do we actually walk away with?

They couldn’t answer those quickly. We couldn’t either, sitting on a call, without opening a spreadsheet.

The math compounds in non-obvious ways. Each post-money SAFE locks in investment divided by cap at conversion. Stacked SAFEs at different caps don’t dilute each other. Founders absorb all of it. Pre-money option pool top-ups come out of existing equity, not the new round. Liquidation preferences hurt at low exits and evaporate at high ones.

Founders sign these terms in moments of high emotion. The lead just committed. The lawyer wants to close. You want to get back to building. The second-order effects don’t surface until years later, by which point your ownership is already where it is.

So we built it. A free, single-page tool that lets founders stack SAFEs at any cap, add priced rounds, top up option pools, set exit valuations, and watch the waterfall move in real time. No login, no spreadsheet.

dilutionlab.canonical.cc

Try it on your own cap table. Drag the exit slider. See exactly how much you walk away with.

We vibe coded it in <30 minutes. The source is on GitHub. If anyone wants to add features or fix corner cases, send a PR.

The new capabilities are real but narrow. Each product gives agents virtual credentials, spending limits, and merchant whitelists. The agent transacts without asking the human to approve each charge. What did not change is the underlying model. Authorization still flows from humans. Chargebacks still require humans to dispute. KYC still binds to human identity. Liability still lands on humans.

The agent looks like a principal, but it is still a delegate.

That works fine for the first wave of agentic commerce, where a human tells an agent to book flights or order groceries. But it doesn’t work for what comes next: agents transacting with other agents, services pricing themselves dynamically per call, software paying software for compute, data, and bandwidth.

Stablecoins are the only payment substrate ever built for non-human counterparties. They are programmable. They settle in seconds with no chargeback infrastructure. An agent can hold a balance, spend it, and transact at any size, including amounts that make no sense on credit card rails. There is no consent loop because consent was never the model.

Even the incumbents are betting on stablecoins: Stripe acquired Bridge for $1.1B, Mastercard bought BVNK for $1.8B, and the Machine Payments Protocol Stripe built with Tempo routes payments natively to stablecoins.

Most of the venture money flowing into the category right now is going to the wrong layer. To see why, it helps to disaggregate the problem.

Agentic payments is not one problem. It is six:

1. How do agents talk to each other?

2. Should one agent believe another?

3. What is this agent authorized to do?

4. What is being bought?

5. Is the transaction legitimate?

6. How does the money actually move?

Most of the noise lives at the coordination layer, where OpenAI, Google, Visa, and Mastercard are racing to set the standard. That’s the layer where the platform players already own distribution.

Anyone building agentic checkout or agent wallet startups in that lane is filling a gap that Stripe Link CLI fills overnight. The product looks right today. It has no moat. The first time Stripe decides to compete in your category, the company is dead.

The wedges that matter for venture sit above and below the coordination layer.

The first is stablecoin-native rails purpose-built for agents. Coinbase’s x402 protocol moved $3M in its first seven days, after eighteen months of moving $80K. Whoever wins this category will build for agents directly, not for humans using agents.

The second is trust and identity for agents. The hard question is whether the agent on the other side of a transaction is real, has a track record, and will pay. The standards are still being written. ERC-8004 is the leading candidate: an Ethereum standard for on-chain agent identity and reputation, jointly authored by MetaMask, Google, Coinbase, and the Ethereum Foundation. Visa’s Trusted Agent Protocol is a centralized alternative.

But standards are not products. The companies that score agent reputation, verify what agents claim about themselves, and price agent risk for merchants and lenders do not exist yet. That is the opportunity. Whoever builds the credit bureau for software wins a category that did not exist three years ago.

The third is what sits on top of payments. Payment processing itself is a low-margin business. The money is in credit, insurance, FX hedging, and yield on the payment flows that the processing creates. Our portfolio company Rain proves this in stablecoin-backed cards: payments are the entry point, credit and rewards are the business. Agentic payments will follow the same pattern. The companies worth backing are not the ones fighting for payment processing market share. They are the ones building credit and insurance products for agents.

The honest counterpoint is that most agent builders today do not hold stablecoins. They have credit cards. So the path of least resistance for the next twelve months runs through Visa and Mastercard. That is true, and it is also why most of the early agentic payment startups will be acquired or killed by Stripe before they have a chance to build a moat. The companies that survive are the ones building on stablecoin rails today, accumulating users, reputation, and credit data, so that when the market shifts, they are already entrenched.

Another mistake the fintech crowd is making: real adoption in payments starts with a killer app. The app creates demand, and the demand drags infrastructure into existence. Stripe scaled because Shopify and Uber needed payment processing. Without them, Stripe is just another API. The agentic killer app has not arrived yet, and most agentic payment startups are building infrastructure ahead of the demand that would justify them. That is survivable. You wait for the app to show up, and you are ready.

But most of these startups are also building on credit card rails. That is not survivable. If the killer agentic app shows up on stablecoins, you cannot swap your foundation. You die.

So the bet is: stablecoin-native rails for agents. Trust and reputation infrastructure where crypto already has the lead. Credit and insurance products on top of agent payment flows. We are backing those companies. The rest of fintech is betting on the wrong rails.

The public market has already noticed. The memory and interconnect layer is being repriced:

This post is an argument for why the next decade of silicon disruption will be decided in memory, and why the second-order effects of AI are reaching all the way down to the device layer of the stack.

How memory and compute actually work today

Every modern computer, including every AI accelerator, runs on an architecture sketched out by John von Neumann in 1945. Memory and compute are physically separate. Data lives in memory. Math happens in the compute unit. Every operation requires the data to travel: out of memory, across a bus, into the compute unit, and the result back again.

This worked beautifully for 50 years. It still works for most workloads. But AI breaks it.

Why? Because AI models are mostly weights: billions of numbers that have to be loaded and multiplied for every single token of output. A 70B model running inference is, mostly, a giant exercise in moving 70 billion numbers from memory to compute, multiplying them by inputs, and putting the results back.

Here’s the punchline: moving a number across a chip costs roughly 100 to 1000x more energy than the multiplication itself. So when your workload is dominated by data movement, as AI inference is, you’ve built a system where the bus, not the silicon, is the bottleneck.

This is what people mean by “the memory wall.”

Where the bottlenecks actually are

The “memory wall” gets used as a single phrase, but it’s really 3 different problems stacked on top of each other:

1. Bandwidth. Can you feed the GPU fast enough? This is what HBM (High Bandwidth Memory) was invented to solve. HBM4 is ramping in 2026. Turing Award winner David Patterson, the architect of RISC, recently called High Bandwidth Flash (HBF) the next bottleneck after HBM. SanDisk and SK Hynix are already collaborating on it.

2. Capacity. Can you fit the model? Industry sources are now reporting that CPU manufacturers are working to integrate 300 to 400GB of DRAM into AI CPUs, roughly 4x what a typical server CPU carries today. Models keep growing. Context windows keep growing. Agentic systems multiply both.

3. Energy. Can you afford to run it? This is the binding constraint. Data center power, not compute, has become the binding constraint Hyperscalers are now siting builds based on where they can find a few 100MWs of electricity. HBM is not just expensive: it’s brutally power-hungry, and a meaningful fraction of that power is going to data movement, not computation.

3 different bottlenecks. One root cause: memory and compute being physically separate.

What the incumbents are doing (and what they aren’t)

The legacy memory industry is dominated by:

• SK Hynix (which holds roughly half the HBM market),

• Samsung, and

• Micron

SanDisk and Western Digital own the NAND flash side.

These are not sleeping incumbents.

Samsung has been shipping HBM-PIM (Processing-in-Memory) silicon.

SK Hynix has its AiM (Accelerator-in-Memory) product.

Micron is scaling HBM aggressively, and its CEO has recently been guiding investors toward dramatic upside in DRAM by 2028.

None of these companies missed the memory wall.

But here’s the structural problem: their P&Ls are anchored to selling more memory, faster. HBM is the highest-margin memory product in history. The economic incentive of the legacy memory business is to optimize the existing hierarchy, not replace it with a memory-compute fusion product that would cannibalize their best margin.

The most thoughtful read on Nvidia’s recent acquisition of Groq was that the value wasn’t in Groq’s compute, but in their SRAM design and the engineering around how memory feeds compute.

Compute-in-memory: the architectural turn

Here’s the alternative to the von Neumann split: stop moving the data. Do the math where the data already lives.

Compute-in-memory (CIM) is exactly what the name says. The multiply-accumulate operations that dominate every AI model (the same handful of arithmetic primitives, repeated trillions of times) happen inside the memory array. The weights never leave the memory cells. There is no bus to traverse. The energy cost of data movement, which dominates everything today, drops toward zero.

This isn’t a new idea. Researchers have been working on it for two decades. What’s changed is that the underlying device technology has finally crossed the threshold where production-grade CIM is achievable. New non-volatile memory devices can store multiple bits per cell, switch deterministically, and stack vertically into 3D arrays. The math finally works.

A few honest caveats. CIM almost certainly augments rather than replaces the existing memory hierarchy. The realistic outcome is a heterogeneous future where CIM handles inference at the edge and persistent weight storage near compute, while HBM and DRAM keep doing what they do for training and high-throughput cloud inference. The lesson from RISC vs. CISC is that the new architecture wins where it wins, but the old architecture rarely dies. The disruption shows up as a new layer in the stack rather than a replacement of the old one.

Why now

3 signals to take seriously.

1. Hyperscaler capex composition. When trillion-dollar buyers shift their composition (from GPUs to power to memory), secondary markets respond. The composition has shifted.

2. Public market repricing already underway. The chart at the top of this post tells the story. Every name on the chart is an industrial memory or interconnect business with real revenue and real customers. The repricing reflects real money concluding the constraint has moved.

3. Structural anchoring of the incumbents. They will optimize HBM. They will ship more PIM. They will not lead the architectural fusion that breaks their own margin structure.

The risk to flag: silicon timelines can be very long. Foundry partnerships, qualification cycles, and design-in to commercial silicon stretch over years. This is a long-cycle structural bet.

The silicon layer is due for disruption. AI’s second-order effects are reaching all the way down.

The bottleneck is not compute anymore.

Software has had a defensibility playbook for twenty years: usage generates data, data improves the product, the product attracts more usage. That flywheel built every dominant software business of the last two decades. Hardware companies never had it. Design data sat trapped in CAD files. Deployment data sat trapped on customer floors. The product shipped and the conversation ended.

Physical AI changes that. A robot arm in a warehouse generates telemetry. Telemetry trains policies. Better policies make the arm more useful. More usage means more deployments. More deployments mean more data. The loop closes, but only if one company owns the hardware, the software, and the deployment surface. Hand any of those off and the loop breaks.

This is what we mean by closed loops. Not vertical integration for its own sake. We mean vertical integration that compounds a learning signal pure-software AI players can’t access and pure-hardware OEMs can’t build.

Our portfolio company Robo Robotics is building exactly this. We call them “the self-replicating robotic arm company” because they build robot arms that build more robot arms. The hardware is standardized so a policy trained on one unit deploys to a hundred. Customer data improves the platform, the platform makes the next arm more useful, and the new arms manufacture the next batch. Hardware, software, and manufacturing in one closed loop.

We’ve also been spending time with a team automating the design of robotic hardware itself. Today they sell that software to robotics companies, who handle the manufacturing and deployment. But the vision we are excited to share with this team is one where they design the part, build it, ship it, and monitor how it performs in the field. Every unit shipped teaches the software how to design a better one. The company becomes the loop.

The pattern generalizes. Anywhere a physical system generates data that improves the next one, there’s a loop waiting to be closed. Most of these wedges are still open because closing the loop requires building competence across three disciplines: software, hardware, and operations. Most founders specialize in only one.

That’s what we’re looking for. Founders who refuse to specialize. Companies where the hardware and the software ship from the same team, and where the data from one improves the other on a daily basis. The loop is the moat.

Inference will 1000x. Even as AI power users, we’ve been reflecting on how we expect to 1000x our own consumption. Dozens of agents today, thousands tomorrow. Half of them running in physical systems, devices, and robotics that haven’t shipped yet. The data center buildout of the last two years was sized for training — a finite, episodic workload. Inference is continuous and compounding, and the real buildout hasn’t started. The investable question shifts from who trains the models to who serves the tokens.

Space and power are gold. Everyone’s watching Nvidia allocation, but we think the actual bottleneck is two layers upstream. Neoclouds and hyperscalers are fighting for places to deploy clusters. Shells go up in eleven months, clusters come online in twenty-one days, GPUs arrive if you pay — but substations take five years and new generation takes ten. The opportunity is colocating next-gen clusters alongside existing twenty-five to fifty megawatt sites with grid interconnect, and locking energy under fifteen-year PPAs before anyone else does.

Sovereign inference. Governments are treating compute like a strategic reserve. In the last two weeks: G42 launched a framework for sovereign AI, Stargate UAE broke ground on a 1-gigawatt OpenAI/Oracle campus, and HUMAIN committed to multi-exaflop capacity with AMD. We think there’s opportunity for new regional neoclouds with local licenses and government relationships — serving sovereign-adjacent customers the big four can’t touch.

Inference silicon is its own market. Inference is projected to be two-thirds of AI compute spending this year, and Nvidia’s training-era architecture isn’t the right answer for serving. That’s why Nvidia paid $20B for Groq and OpenAI just committed $20B to Cerebras, which filed to IPO at $35B last week. The frontier LLM inference chips are already captured. We think the venture opportunity is the next wedge — novel architectures for workloads Nvidia never designed for: transformer-specific ASICs, analog and photonic compute, modality-specific silicon for video, audio, and robotics.

Wall Street is mispricing GPU depreciation. The bears say hyperscalers are overstating profits by $176B through 2028 because GPUs only last three years. We think the data says otherwise. H100 spot prices dipped after launch, then climbed above launch prices as workloads pulled demand forward. The real pattern is a value cascade — training in years one and two, inference serving in years three through six. The venture opportunity is the long tail: networks that turn aging enterprise GPUs into productive inference capacity.

We’ll share another edition next week.

The argument is surprisingly concrete. Current AI agents can’t hold assets, can’t receive payments directly, and have no persistent identity across platforms. Xu proposes a five-layer blockchain stack that solves all three: DePIN for physical infrastructure, W3C DIDs for machine identity, RAG and MCP for cognitive tooling, account abstraction for settlement, and collective governance for coordination. The whole architecture is designed so machines can participate in markets the way humans do.

The idea has an eight-year paper trail. Sentis and Arduengo proposed robots transacting via self-executing smart contracts back in 2018. The AI and the blockchain infrastructure weren’t mature enough, but the core intuition was the same — machines need a way to commit to agreements, verify execution, and settle payment without relying on a legal system or a human intermediary. Rothschild et al. at Microsoft Research arrived at a similar conclusion from the market design side in 2025. The convergence from robotics, market economics, and blockchain research independently is what makes this feel like more than a whitepaper.

And then showed what it actually looks like running. A humanoid 3D-printed a part and requested delivery through their Agent Commerce Protocol. A rover transported it to a shipping point. A drone flew it to final delivery. Each handoff negotiated its own price and settled payment onchain on Base using x402 and USDC. Three robots from three companies completing an autonomous supply chain. No human touched the package or the money.

The reason blockchain keeps showing up in these architectures is practical, not ideological. When three robots from three different companies need to coordinate a transaction, you need identity that persists across platforms, payments that settle without a shared bank account, and a coordination layer that works across organizational boundaries. Centralized APIs can’t do this cleanly. Blockchains can.

The agentic economy is being discussed mostly as a software phenomenon today: agents booking flights, negotiating prices, managing inboxes. But it might arrive through hardware first. Machines that move through physical space, settle their own payments, and coordinate without a human in the loop. That’s the version Xu’s paper describes, and the Virtuals demo just proved it works.

Blockchains might just be the substrate for physical AI.

We’ve been thinking about what comes after single-agent AI. Today’s agentic tools are powerful but single-threaded — one agent, one task, one human supervising. OpenClaw showed what a single autonomous agent could do. The next phase is multi-agent harnesses: systems where agents collaborate horizontally on long-running tasks, maintaining coherence for days without human intervention. Early signals suggest well-orchestrated multi-agent topologies outperform single agents significantly, even with sub-frontier models. These systems also work best mixing models from different labs — which means no single lab will build this themselves. The infrastructure for multi-agent communication, topology optimization, and long-running orchestration doesn’t exist yet. We think this is the next big opportunity in the AI stack.

Robotics may be crossing the reliability threshold that unlocks deployment. GEN-1, a new embodied foundation model, achieves 99% success rates on production tasks — up from 64% in the previous generation — while running 3x faster. It needs only one hour of robot-specific data to adapt to new tasks. The demos aren’t lab tricks: kitting auto parts for an hour straight, folding 86 shirts consecutively, servicing robot vacuums 200+ times in a row. We’ve written before that the gap between lab and production is the real barrier in physical AI. If 99% reliability holds in the wild, the deployment floodgates open, and the bottleneck shifts to integration and operations.

Agentic commerce is already here — but the infrastructure war is just starting. Stripe captured the first beachhead by partnering with OpenAI, letting agents complete normal consumer purchases inside ChatGPT. That single integration locked the largest AI platform into one payment rail. Now every other PSP — PayPal, Visa, Adyen — has to make their rails agent-compatible or risk losing the next wave of e-commerce entirely. The question isn’t who builds the best agent payment protocol. It’s which payment rails agents default to. We think whoever owns the orchestration layer between agents and PSPs — and the merchant distribution behind it — wins.

Stablecoin issuance is commoditizing. A growing wave of white-label issuers — Paxos, Bridge, Anchorage, M0 — now handle the full stack: compliance, treasury management, minting, and redemption as a service. The process is becoming standardized and low-margin, which means the moat in stablecoins is shifting from who can issue to who has distribution. Tether and Circle dominated for five years because their edge was liquidity depth and exchange integrations that created a flywheel no one could replicate. The long tail of issuers won’t win by competing head-to-head. Paxos is instructive: by providing issuance infrastructure while partners like PayPal handle distribution, Paxos-issued assets went from roughly $1B to $7.75B in a year. Distribution is the moat.

The biggest AI companies are giving up on the grid. 30% of all planned data center capacity is now on-site — up from near zero a year ago. Chevron is building a dedicated gas plant for a Microsoft data center in Texas. McKinsey estimates a third of incremental demand through 2030 will be met behind the meter. The reason is simple: interconnection queues take years, and AI timelines don’t wait. We’ve written about how coordination, not generation, is energy’s real bottleneck. Now the largest buyers are proving the point — by routing around the grid entirely. We think the second-order effect matters most: if the highest-value customers leave, the grid loses its best anchor tenants, and the investment case for upgrading it gets harder, not easier.

We’ll share another edition next week.

Teleoperation is the blindspot of robotics. The prevailing narrative is that we’re waiting for AI to solve autonomy, but teleoperation is the apprenticeship that produces it. When a human teleoperates a robot, the data has zero domain adaptation gap. Waymo proved this: one intervention every 1,250 miles in 2015, 17,000 today, trained by teleoperators generating exactly the data to make the next intervention less likely. We think teams building the control layer (fleet coordination, handoff from 1:1 to 1:100) will own the next chokepoint in physical AI.

AI is becoming a first-class security actor. In a live demo, Claude discovered zero-day vulnerabilities in Ghost. 50,000 GitHub stars, no prior critical CVE, finding a blind SQL injection and stealing the admin API key in 90 minutes, then doing the same to the Linux kernel. Vulnerability discovery has always been bottlenecked by scarce human expertise. If AI can find zero-days at this speed, the economics of offense and defense shift fundamentally. We think the investable surface is autonomous security agents that treat vulnerability discovery as a continuous process, not a periodic audit.

Drug discovery is moving from copilot to autopilot. Latent Labs launched Latent-Y, an autonomous agent for end-to-end drug design — give it a research goal and it reasons, designs, iterates, and delivers lab-ready antibodies without human intervention. We wrote in Week 14 about drug discovery search becoming software. Latent-Y closes the loop: hypothesis to validated candidate, autonomously. We think the teams that own the full design-to-validation workflow will compress timelines that used to take months into days and reshape early-stage biotech.

What is the actual TAM for physical AI? We’ve been discussing internally: most AI investment is concentrated in white-collar automation — coding, writing, analysis. But the physical world is where the majority of economic activity and labor sits. More people drive, build, manufacture, and serve than write software. The market for physical AI is far larger, purely because the surface area is bigger. We think current venture allocation toward software-only AI dramatically underweights the opportunity, and the largest outcomes will come from teams moving intelligence into atoms, not just bits.

America’s energy problem isn’t supply — it’s delivery. Generation is getting cheaper, but delivery now accounts for nearly half of customer electricity costs. 70% of US transmission lines are over 25 years old, transformer demand has doubled since 2019, and 80% of supply is imported. We’ve written about how coordination, not generation, is energy’s real bottleneck. One emerging fix is solid-state transformers on silicon carbide — software-controlled power conversion replacing passive hardware with programmable nodes. We think the next wave of energy infrastructure looks like Moore’s Law applied to the grid.

We’ll share another edition next week.

The Inner Game of Robots. The moat in robotics is the data flywheel. You can’t program physical intelligence with rules, you have to learn it from real-world interaction data, and that data is expensive, slow, and environment-specific. This matters because simulation won’t close the gap for manipulation, so the teams that deploy into real workflows first will compound the best datasets. We think Physical AI will be won by distribution, because distribution is how you earn the data.

World models will allow robots to think. If an LLM asks “what word comes next?”, a world model asks “what happens next in the physical world if I do this?” This matters because robot data is scarce and slow to collect, but video data is abundant, and predicting the world is a way to learn physical intuition from internet-scale footage. We think the winners will be those that learn enough “what happens next” to plan and act reliably in the real world.

EgoVerse is a new ecosystem for robot learning from egocentric human data. It includes 1,300+ hours across 240 scenes and 2,000+ tasks. This matters because egocentric data serves as a clean bridge between abundant human video and scarce robot-interaction data, providing robots with “priors” for how hands actually manipulate the world. We think the teams that win physical AI will own the data substrate, not just the model.

Robotics needs fewer roboticists per capita. Real-world deployment is still rare because robotics culture has optimized for novelty over reliability and integration. This matters because deployment is the forcing function that creates the data flywheel, and that requires operators, product builders, and systems engineers as much as PhDs. We think the first breakout robotics companies will look more like industrial software companies than research labs, with distribution and operations as the moat.

Physical Superintelligence open-sourced Get Physics Done, an AI copilot built specifically for research-grade physics. It turns “a question” into a structured workflow, moving the bottleneck in AI-for-science from raw intelligence to rigor, process, and making work reproducible over weeks, not minutes. We think the next wave of scientific AI looks less like chat and more like opinionated research operating systems.

We’ll share another edition next week.

What if AI makes every moat temporary? If disruption gets cheap enough, markets may stop paying for year 7+ cash flows because they become unknowable, and equities start trading like short-duration assets priced on near-term cash. That would kill the logic of growth investing and force capital toward short-duration cash flows. We think the new definition of defensibility is “hard to copy quickly,” usually workflow embedding, data advantage, or physical and regulatory constraints. We also think founders should optimize for time-to-scale, because speed is an increasingly important moat.

GPU compute financialization. Oil took a century to evolve from a physical commodity into a full derivatives market. We think GPU compute could do it in years because its secondary markets are digital from day one. Once compute is tradeable, it becomes financeable: spot prices turn into forward curves, and forward curves unlock credit, hedging, and leverage. We think this goes onchain first as GPU-backed financing and forward contracts, then later as a simple “trade compute” market.

Agentic payments stack. Agentic payments are turning into the internet’s missing protocol layer. ACP, UCP, x402, and AP2 all solve different layers: discovery, trust, authorization, and settlement. This matters because agents can’t be autonomous if humans still have to approve every checkout, top up every balance, or mint every API key. We think the long-run unlock is machine-to-machine commerce, agents paying for compute, data, and APIs at machine speed, and stablecoins are the obvious rail.

DeFi credit ratings. Crypto-collateralized lending hit a record $90B, and onchain private credit has more than doubled over the past year to $25B today, but institutions still represent only ~11.5% of DeFi TVL. We think the next unlock is standardized, transparent risk ratings across DeFi. When risk parameters, curator actions, and liquidation logic are onchain and auditable, you can build an open risk layer that’s too opaque or costly to coordinate in TradFi.

Drug discovery search becomes software. Researchers built an AI system that can search billions of possible drug molecules against a protein target in only 7 days, then tested the best picks in the lab and found real hits. This matters because the expensive part of early drug discovery is often “where do we even start?”, and AI is turning that search step into software. If this keeps improving, the bottleneck shifts from finding candidates to running experiments and trials, meaning smaller teams can take more shots on goal.

We’ll share another edition next week.

Manufacturing AI may be reaching an economic inflection point. Computer vision can now make workflows across factories, farms, construction sites, and warehouses measurable at far lower cost than human oversight, while turning everyday operations into structured data. The key question is whether the gains from optimizing human labor compound long enough to matter, or whether robotics and automated factories arrive before that layer fully matures.

Google solved a theoretical physics problem using Gemini. They paired Gemini Deep Think with tree search and automated numerical feedback to brute-force its way to a correct proof, like a digital scientist. This matters because “AI for science” is starting to produce closed-form answers, not just guesses or partial approximations, and that’s when it begins to change the pace of discovery.

Yann LeCun’s new paper says AGI is the wrong goal – instead, we should build superhuman specialists that adapt fast. He argues humans are “general” because evolution tuned us for survival, and copying that would be the wrong approach for AI. He proposes Superhuman Adaptable Intelligence, measuring how quickly systems learn new skills using self-supervised world models. We’ve long held the view that the future is fast-learning specialist models that compose, not one model that does everything.

The U.S. DOE announced a $1.9B funding opportunity to accelerate grid upgrades. The constraint for AI-era energy is increasingly not generation, it’s coordination and delivery – getting electrons to the right place on the right timeline. Our contrarian take is that the huge opportunity isn’t just in generating power, it’s in interconnecting it.

Intel demoed Heracles, accelerating fully homomorphic encryption (FHE) by up to 5,000×. FHE lets you compute on encrypted data, but has been unusably slow. If this crosses the cost threshold, it unlocks private AI by default, models can run on sensitive data without ever seeing it. We think this becomes a new infrastructure layer for enterprise AI.

We’ll share another edition next week.

AI abundance creates builder paralysis. As agent tooling gets absurdly powerful, more builders feel stuck on what’s worth building, because so much software starts to feel commoditized. This matters because as intelligence becomes abundant, differentiation shifts to scarce constraints, real-world deployment, and distribution. We think venture-scale winners will be the platforms and infrastructure that unlock “atoms at scale” (robot deployments, energy, compute, regulated workflows, logistics) and the coordination primitives (including crypto networks) that turn these ecosystems into modern utilities, not another software wrapper.

MIT launched NeuroSkill, a brain-computer interface integrated with foundation models. It uses brain signals to infer cognitive state, then runs an offline agent loop that can respond to your state, not just prompts. This matters because “state” is a new input channel for agents, enabling interfaces that adapt in real time and opening new possibilities for human-AI interaction.

Physical Intelligence built a memory system for robot models, giving them short-term and long-term memory so they can complete long-horizon tasks, like cleaning a kitchen or making a sandwich. When the robot makes a mistake (e.g., opens the fridge door the wrong way), it remembers and tries a different strategy. We think memory will become core robotics infrastructure, because reliable robots must remember, recover, and adapt, not just act.

Humanoid robotics are marketing and hype. In most deployments, wheels beat legs because legs add safety and compliance friction, plus cost, for marginal gains. This matters because as bodies commoditize, the bottleneck shifts to trust, integration depth, uptime, and scaling from one site to many. We think winners will be the teams with a repeatable deployment playbook (EHS/OSHA cleared) and software that embeds robots into workflows so they are hard to rip out.

REMem pushes “agent memory” beyond RAG, storing past events with context (who/what/when/where) so agents can reason across a timeline, not just retrieve documents. This matters because long-running agents will fail without event memory, they lose continuity and repeat mistakes. We think memory becomes a first-class layer in the agent stack, and winners will treat it like structured state, not a bigger context window.

We’ll share another edition next week.

Inception AI launched the fastest LLM in production. This matters because if diffusion can reliably deliver low-latency generation at scale, it changes the unit economics of agentic workloads where speed and cost compound across many calls. We’ve written before about how diffusion is a sleeper architecture for language because latency advantages will help make real-time, always-on agents finally practical.

NVIDIA released PersonaPlex-7B, an open full-duplex voice model that can listen and speak at the same time. This matters because most “voice agents” still feel like walkie-talkies; full-duplex is what makes conversation feel natural. Our take: voice becomes the default UI once latency and interruption handling are solved, and open models like this speed up that transition.

Narrative violation: coding jobs are rising, not falling. Software engineering postings have surged 15%+ since late 2025, despite AI coding tools proliferating. AI isn’t replacing programmers—it’s creating “vibe coders” who ship functional code through AI assistance. Our take: the bottleneck shifts from writing code to reviewing it, creating huge demand for AI tools that manage AI-generated contributions.

Google built MapTrace to teach world models “spatial grammar”. They generated 2M synthetic map-path pairs with an automated creator-critic pipeline. This matters because navigation and robotics are bottlenecked less by language and vision, and more by structured spatial supervision. Our take: synthetic data factories for physical reasoning will be a moat, because they turn limited supervision into a scalable input.

Alibaba’s latest open-source LLM beats o3, Sonnet 4, Grok 4, and DeepSeek’s 656B. This matters because near-frontier capability is now downloadable under permissive licensing, shifting advantage from model access to product integration and distribution. Our take: open weights commoditize the base model layer, and the moat moves up-stack to great apps, workflows, and feedback loops.

We’ll share another edition next week.

While many of our peers are hiring “Heads of AI” to build internal tooling, at Canonical, both Anand and I are building ourselves. Two reasons: nobody understands our workflows, pain points, and preferences better than us, so the best tooling is custom. And, as investors in AI, we think it’s important to feel the curve from the inside - the gap between reading about AI and building with AI daily is massive.

We use AI to buy back attention, not outsource judgment. The goal is to automate repetitive, high-volume parts of venture - both things we previously did and found monotonous and things we never had the bandwidth to do - first-principles thesis work, founder support, deep diligence and reference checks, and high-context relationship building.

How we use AI at Canonical today:

We run an agent that monitors newly published academic papers across frontier tech and AI. It tracks them in a living spreadsheet, tags them by category, and flags the ones that matter based on our internal thesis. This is a deal flow tool: the best founders often show up as authors before they appear in your inbox. Over time, we want this workflow to automatically pull context on authors and labs so outreach becomes faster and higher signal.

We run an agent over our email deal flow. Any deal we get sent gets triaged: the system detects whether it is an investable opportunity, extracts key fields into our CRM, and produces a structured readout against our deal criteria. The objective is not to “decide for us,” but to ensure every inbound gets a consistent first pass, and that nothing slips through cracks when volume spikes.

We run an agent over call notes and transcripts. It routes them into the right CRM entities (founders, companies, LPs), updates the record, and pulls out the cleanest takeaways. This has become one of the most leveraged parts of our process because it turns conversations into compounding institutional memory. It also feeds directly into how we generate these weekly entries.

Where this is going next is even more interesting: agent identity. Most “agentic” systems today still assume the agent is just an extension of the user, operating with the user’s permissions. That model worked for cloud software because it made integrations simple. But systems like OpenClaw reveal the next phase: agents that operate more like colleagues, running independently and in parallel. With this, firms will need scoped access, sandboxes, auditability, and clear blast-radius controls. The winners will not just adopt agent tooling; they will train a small set of firm-specific agents and govern them like real actors inside the org.

We’ll share another edition next week.

Robotics is becoming a data compounding problem. Pre-training on egocentric video scales; post-training dexterity does not. Teleoperation is expensive and often breaks the natural sensorimotor loop, producing brittle behaviors that fail outside the lab. A new wedge is emerging around low-latency glove capture and UMI-style pipelines that preserve reflex-level human behavior at lower cost. If that feedback loop compounds, the edge won’t be a better model alone, but the cleanest pipeline from human instinct to robot policy.

China’s robotics lead is a supply chain story, not a demo story. Actuators, reducers, motors, sensors, and precision components sit within dense regional clusters that have compounded over 30+ years, iterating at industrial speed and compressing BOMs in ways the US cannot easily replicate. If hardware cost and scale structurally tilt toward China, durable venture value will not sit in commoditizing components. It accrues higher in the stack: world models trained on real interaction data, dexterity capture systems, autonomy software, and distribution that turns capability into revenue.

OpenClaw made it obvious: agents are about to start spending. Once they do, agent finance becomes inevitable. The bottleneck is not payments, but trust: identity, underwriting, disputes, and liability when software acts on your behalf. The interesting play is underwriting agent behavior directly from transaction data, then turning that into credit, insurance, and guardrails for users and merchants. If that underwriting loop compounds, “agent risk” itself becomes a new financial primitive.

Stripe’s machine payments is the missing rail. OpenClaw showed agents will act; Stripe ensures they can transact. With stablecoins abstracted behind familiar APIs, agent-native commerce moves from experimental infra to production settlement. The shift is subtle but important: AI is no longer just generating content, it is initiating economic activity.

Zhipu’s GLM-5 reflects where the model frontier is heading. Open-sourced and optimized for long-running tasks and tool invocation, it is designed less for chat benchmarks and more for agent execution. In interactive tool settings, it competes with or exceeds closed incumbents, and its rapid release cadence signals an accelerating open ecosystem. The competitive axis is shifting from raw intelligence to reliability inside workflows, where developer-aligned, agent-optimized stacks may compound faster than monolithic closed models.

We’ll share another edition next week.

For most of crypto’s history, credit was something to be avoided. Lending systems were designed to eliminate risk rather than price it, relying almost exclusively on overcollateralization and reflexive demand to function. Yield, when it appeared, was a byproduct of leverage and incentives, not durable cash flows.

That is starting to change.

Over the past year, a new class of protocols has emerged that run credit explicitly onchain. Instead of trying to engineer risk away, these systems generate yield by financing real economic activity: lending to specific counterparties, underwriting real-world risk, or funding assets with predictable revenue. The mechanics differ, but the common thread is simple: yield is increasingly tied to who is borrowing, why they need capital, and how losses are handled when things go wrong.

Where Stablecoin Yield Actually Comes From

To understand why this shift matters, it helps to separate stablecoin yield into its underlying components. Despite the diversity of products and narratives, much of the new onchain yield emerging today comes from a small number of economic sources.

1. Capital Where Banks Can’t Go

This exists wherever there is a structural mismatch between who can lend cheaply and who needs capital. In many markets, traditional lenders are constrained by regulation, risk-weighting, or operational and compliance friction, even when the underlying assets generate predictable cash flows. The result is a higher cost of capital driven by regulatory and operational constraints.

Stablecoins efficiently step into these gaps. Protocols like USD.ai finance infrastructure assets like GPUs that banks are poorly positioned to underwrite, while others like Daylight target energy and infrastructure financing more broadly. In these cases, yield compensates investors for supplying capital where legacy balance sheets cannot, or will not, operate.

2. Underwritten Credit

This is where yield is explicitly compensation for default risk. Capital is lent to identifiable borrowers, and losses are explicitly planned for, rather than treated as tail events to be engineered away.

What matters most in these systems is not the headline rate, but how losses are allocated. Who absorbs first loss? How much protection exists above them? And how quickly can capital exit when conditions change? Overcollateralization was the dominant answer in earlier DeFi systems, but it is no longer the only one.

Protocols like Wildcat extend undercollateralized credit to institutional counterparties based on reputation and relationship-driven risk assessment, while 3Jane focuses on smaller operators and merchants with measurable cash flows. In both cases, yield is inseparable from borrower quality and loss structure.

3. Insurance & Risk Pools

These systems generate yield by absorbing volatility that others prefer to avoid. Participants earn premiums in exchange for taking on exposure to specific categories of risk.

This is structurally different from lending. Returns tend to be uneven, with long periods of stability punctuated by drawdowns. Returns depend less on steady utilization and more on whether losses arrive independently or all at once, which is why leverage can dramatically amplify downside.

Reinsurance protocols like Re (auto, homeowners, small business) and OnRe (catastrophe) both sit in this category, but with very different volatility profiles depending on the risks they underwrite. The distinction between them is not whether yield is “real,” but which risks are being priced, and how transparent those risks are to capital providers.

From Tokenization to Credit Design

What’s interesting about this moment isn’t that assets are being brought onchain. Tokenization by itself is not new, and it’s rarely the hard part. The harder problem is designing credit systems around those assets that can scale, survive stress, and allocate losses clearly.

The real innovation is not the wrapper, but the structure. How underwriting is done. Where first loss sits. How liquidity is gated. How quickly risk becomes visible to capital providers. Two protocols can both advertise “real-world yield” while one behaves like senior secured financing and the other like a volatility-selling strategy.

Seen this way, the recent wave of “stablecoin yield” and “real-world assets” is less about a single onchain credit narrative and more about a growing range of distinct designs. Yield now reflects how credit is structured, including who borrows, who absorbs losses, and how capital moves under stress. Different protocols express different balance sheets onchain, each with its own assumptions about risk, trust, and time.

That is the shift. Crypto is no longer just moving dollars or wrapping assets. It is starting to design credit.

What Unlocks Onchain Credit

What makes this moment interesting is not just that credit is being rebuilt onchain, but that crypto is beginning to expand the frontier of what credit systems can do. Blockchains, stablecoins, decentralized exchanges, and cryptographic primitives are converging into a stack that allows capital to move, price risk, and settle globally in ways that traditional finance simply does not offer.

This is why emerging technologies like zkTLS matter. Credit depends on facts: revenues, utilization, balances, insurance coverage. zkTLS makes it possible to verify those facts without fully revealing them or routing them through centralized intermediaries, allowing real economic activity to be underwritten onchain while preserving privacy and minimizing trust assumptions. Protocols like 3Jane use this to enable unsecured lending based on cash flows rather than collateral, while others apply similar primitives to infrastructure financing, institutional credit, or insurance underwriting, as seen in USD.ai, Wildcat, and Re. The common thread is the expansion of what can be verified, priced, and financed onchain.

More broadly, these systems point toward a future where sophisticated credit products are no longer gated behind institutional balance sheets or geographic boundaries. Retail capital can participate directly in financing infrastructure, underwriting risk, or extending credit to real businesses, with transparency and control that rarely exists in traditional markets. If this trajectory holds, onchain credit will not just compete with existing financial rails. It will materially widen the frontier of finance itself.

Credit Is the Real Test of Crypto

Credit is where financial systems are forced to confront reality. Defaults happen. Liquidity disappears. Risk concentrates in uncomfortable places. For most of its history, crypto avoided these constraints by design, leaning on overcollateralization and reflexive demand to scale quickly without confronting loss. What’s different now is that onchain systems are beginning to engage with these realities directly, not as failures to be patched over, but as inputs to be priced and structured.

If crypto can build credit systems that survive stress, allocate losses transparently, and expand access to sophisticated financial activity beyond traditional gatekeepers, then everything else follows. Not because yield is higher or rails are faster, but because the system is doing something genuinely new. Onchain credit is hard. That’s precisely why it matters.

Special thanks to Armen Ter-Avetisyan and Conor Moore for helping me with this post.

DeepMind shows that an LLM’s “belief representations” can swing dramatically across a single conversation. In edge-case dialogues (consciousness, delusions, role-play-heavy contexts), internal representations of factuality can flip as the model shifts roles, while clearly fictional “sci-fi” framing stabilizes them. This makes interpretability less construct-valid. Our take: alignment is increasingly a stateful, conversational property, which means we’ll need coordination primitives (audit trails, provenance, shared oversight), not just one-shot “steering,” to manage safety.

What if a single framework could unify every AI agent? A new paper from ByteDance proposes a general architecture that spans both software agents and physical robots: task-oriented systems that use LLMs for reasoning, reinforcement learning for behavior, and tools plus long-term memory for execution. Our take: progress will come less from inventing new “agent types” and more from standardizing this stack, making agents easier to compose, reason about, and eventually govern at scale.

World models are the second pre-training paradigm. Models are now learning to predict how the physical world evolves under action. Video generators are the shallow end of this shift; the deep end is learnable physics simulators that reason in vision-first, action-conditioned space. We’ve written before about why this matters for robotics and Physical AI. Our take: 2026 is the year world models stop being a curiosity and start becoming the substrate for robotics, multimodal agents, and real-world autonomy, with language receding from foundation to scaffold.

Physical commonsense is the missing substrate in robotics. Humans rely on reflexive, closed-loop corrections (nudges, regrips, recoveries) that feel automatic. This kind of intelligence isn’t linguistic; it lives in the sensorimotor loop for robotics and only emerges when data preserves real interaction, not slow, stilted teleoperation. We think the next step-change in robotics comes from better priors learned from reflex-level human behavior, not better planners, and the teams that capture this will own generalization.

Hyperliquid launches outcome trading, a general-purpose primitive for prediction markets and dated, bounded options. This expands HyperCore beyond perps into a broader derivatives substrate. Our take is that this is a real step toward “everything exchange” behavior, with the open question being whether Hyperliquid can keep adding primitives without sacrificing the simplicity and reliability that made it win in the first place.

We’ll share another edition next week.