AI and Crypto: Where the Two Technologies Actually Converge

The phrase "AI plus crypto" has become a fundraising reflex. Attach a model to a token, gesture at a decentralised future, and raise. Most of these projects fail a basic test: remove either the AI or the chain and the product is unchanged. That is not convergence — it is a narrative trade dressed as infrastructure.

But dismissing the whole category is lazy. There are places where the two technologies are genuinely complementary, where one solves a problem the other structurally cannot. The job is to separate those from the noise. Below are the intersections we think survive scrutiny, ranked roughly by how real they are today.

Start with the question that filters the hype

For any AI-and-crypto claim, ask one thing: does the AI need a blockchain to do something it otherwise couldn't, or does the chain need AI for the same reason? If the answer is no in both directions, you are looking at marketing. The genuine intersections all share a property — they involve coordination, payment, or verification between parties that do not trust each other. That is precisely the problem space crypto was built for.

Autonomous agents that hold wallets

This is the most concrete intersection. An AI agent that can act on the world needs to transact — pay for an API call, settle a task, hire another agent. Traditional payment rails assume a human with a card, KYC, and a bank that is open. Agents are none of those things. They are software that runs continuously, in any jurisdiction, at machine speed and machine scale.

Crypto gives an agent something it cannot get elsewhere: a native account it controls directly, programmable money it can move without a human in the loop, and stablecoins as a unit of account that does not require a banking relationship. Machine-to-machine payments are where stablecoin demand from AI is most plausible — not as speculation, but as working capital for software that buys and sells services. The design problems here are real: spend limits, key custody for non-human actors, and revocation when an agent misbehaves.

Verifiable compute and provenance

As models make more decisions, "trust me, the model said so" stops being acceptable. The open question is how to prove that a specific model produced a specific output, on specific inputs, without re-running it yourself. This is where cryptography earns its place rather than borrowing the brand.

• Inference attestation — proving a particular model and weights generated an output, so a counterparty can verify rather than trust the operator.
• zkML — zero-knowledge proofs that an inference was computed correctly, letting a chain or a user check the result without seeing the model or redoing the work.
• Provenance trails — signed, timestamped records of what data trained a model and what produced a given output, anchored where they cannot be quietly rewritten.

Be clear-eyed about maturity. zkML is advancing quickly but remains expensive for large models, and much of it is still closer to research than production. The direction is right; the timelines in most pitch decks are not.

Decentralised compute and data marketplaces

Training and serving models is bottlenecked on GPUs and on data. The thesis is that crypto can coordinate idle hardware and unlock datasets that no single company owns, using tokens to clear a two-sided market. The thesis is sound. The execution is mostly an incentive-design problem, and that is where these networks live or die.

A GPU marketplace has to solve verification — how does the buyer know the work was done, on the hardware claimed, correctly — and it has to compete with hyperscalers on reliability, not just price. A data marketplace has to price quality, prevent poisoning, and handle the fact that data can be copied the moment it is sold. None of this is solved by issuing a token; the token is the easy part. The hard part is the mechanism that makes honest behaviour the profitable strategy, the same discipline we apply to DeFi incentive design.

Crypto rails as a coordination layer

Step back and a pattern emerges. In each genuine case, crypto is not making the AI smarter — it is the settlement and coordination layer underneath a network of AI participants. Payments between agents, rewards for compute providers, staking that backs an honesty guarantee, governance over a shared model. Crypto is the economic substrate; AI is the workload running on top.

The useful question is never "is it AI plus crypto." It is: who are the untrusting parties, and what are they coordinating?

Content authenticity against synthetic media

Generative models have made convincing fakes cheap. The defensive counterpart is provenance: cryptographically signing content at capture or creation, so a viewer can verify origin and edit history rather than guess. Crypto's contribution here is a tamper-evident, vendor-neutral record of authenticity. It will not stop deepfakes, but it can give genuine content a verifiable signature that synthetic content lacks — a meaningful asymmetry if adoption reaches the devices and platforms where media originates.

The token that isn't really AI

Now the part most articles skip. A large share of "AI tokens" have no AI in any load-bearing sense. The model is a third-party API, the inference happens off-chain on someone else's servers, and the token funds the team while supplying a narrative. There is nothing decentralised, nothing verifiable, and nothing the token does that a Stripe account would not do better.

The incentive-design challenge for networks that are real is genuinely hard, and it is the part worth underwriting. An AI network has to reward useful work — good inference, honest compute, high-quality data — and it has to do so in a token whose value does not collapse the moment emissions slow. That is the same reflexivity trap that breaks ordinary token economies, with an extra constraint: the "work" is often expensive to verify. If you cannot cheaply check that a participant did what they claim, your incentive layer is paying for assertions, not output. Designing around that is the core of token ecosystem design for AI.

Our default posture is skeptical and specific. Name the untrusting parties, name the thing being coordinated, and show why a chain is load-bearing rather than decorative. If a project survives those three questions, it is worth serious attention. If it does not, no amount of GPU imagery changes the verdict. When you want a sober read on where a project actually sits, talk to us.