Illia Polosukhin 谈 AI、加密货币的未来，以及 NEAR 将如何胜出
- Illia称，NEAR Intents月处理量约40亿美元，协议费用会转换为买入NEAR。 near.com按周贡献10–20%的交易量；perps和Earn也会将部分费用用于回购。他的说法是，“每款产品实际上都在创造收入，然后回购NEAR”，但没有给出累计回购金额。
- NEAR的战略如今也包括亲自打造面向消费者的金融产品。 near.com于2月在NEARCON发布，整合跨链资产、兑换、支付、股票、perps和Earn，并提供生物识别登录；其私有分片运行在安全隔区内。Illia将更广泛的业务形容为“面向AI与区块链未来的垂直整合技术栈”。
- Illia认为，更大的机会是借助AI智能体，将20万亿至40万亿美元的商业交易搬上链。 智能体负责寻找交易对手并谈判，区块链则为彼此缺乏信任的企业提供托管、结算和争议处理基础设施。“AI是前端，区块链是后端”：目标是那些受法律摩擦拖累的商业关系，而消费者买菜早已高度优化。
- Illia认为，处理资金的智能体需要可验证的推理能力和明确的支出限额。 任意模型端点——尤其是路由服务或免费模型，也包括部分实际服务商——可能替换模型或返回恶意指令：“你根本不知道后面跑的是什么。”Near ID给出的方案是对GPU、模型和软件来源进行签名验证；金融智能体的策略引擎则要求其在超出权限前取得批准。
- 一次涉及合作方所建BSC连接的380万美元漏洞攻击，暴露出NEAR集成测试的缺口。 Illia称，团队在1小时内恢复系统，并在确认攻击者身份后实现“100%追回”；同时承认，该连接此前测试不足。NEAR正加快对相互作用的合约进行验证；他称验证成本较其所说的“使用OpenAI，比如Sol或Astra”降低了100倍，但转录稿中的比较对象并不清楚。
- Avi提出的核心商业难题是：技术再强，也不会自动带来用户或分发能力。 Illia称NEAR现在采取“销售优先”的方式，举例包括钱包集成、Venice的端到端加密模式、Brave的智能体将NEAR列为选项，以及非加密、非AI领域的设计合作伙伴。具体的智能体商业案例，是一家活动公司通过预订场地，将其场地数据库变现；其目标商业模式是“按结果付费”。
1. AI愿景早于NEAR，发展速度取决于算力
Illia支持去中心化货币的理由，始于祖父母存在Sberbank的积蓄在苏联解体后化为乌有。在苏联解体后的乌克兰，他记得面包价格大约在1年内涨了100倍：“当时货币已经失灵。”另一个转折来自竞赛编程：14岁时，他就认定“这段代码应该由机器来写”。
2012至2013年前后，Google的一项实验带来了新的突破：一个无监督模型从未标注的网络图片中学会了“猫”的概念。Illia说，那是Jeff Dean和Andrew Ng的一篇论文；据他回忆，模型在约600台机器上训练。更广泛的神经网络突破，则来自Geoffrey Hinton和Yann LeCun让多层网络与反向传播真正跑通，数学和算力也逐渐跟上。Illia想把同样的能力用在语言上：动物能看，人们却通过提问来检验智力。于是他加入Google，研究问答系统。
在Google时，瓶颈在算法：循环神经网络一次读一个词，训练缓慢，还可能忘记长文档的开头。他早期的解决方案是把词映射成向量，再按段落求和；由此做出一个快速、简单的问答模型，约在2015至2016年上线google.com。Transformer进一步实现并行计算，让GPU能够用更多数据训练更大的模型。
为解释注意力机制的层次，Illia举了“猫坐在墙上”这个例子：先把“猫”和“坐”联系起来，再把这个组合概念与“墙”联系起来。他说，KV cache会保留处理结果，让后续问题能够复用。OpenAI接下来的做法是“把这套东西的规模彻底拉起来”，从GPT-1、GPT-2一路发展到ChatGPT；同一架构也适用于图像、声音和视频。
2. 微支付难题，演变成一场耗时两年的区块链建设
2017年，Illia和联合创始人Alex在GitHub上训练Transformer，目标是让计算机直接按用户要求办事，取代一个个独立应用和SaaS服务。但算力有限。他们招募东欧、东南亚和中国的学生编写代码和说明文档，随后发现，要跨越彼此割裂的银行与支付系统向贡献者付款，本身就是个难题。
加密货币原本要解决全球微支付问题，但到了2018年，交易费已经高于他们付给学生的报酬。于是他们打算绕道，先做一条易用、交易费低且不会随使用量上涨的区块链。分片、账户抽象和WebAssembly都源于这些需求。Illia回忆：“6个月就能做完。”原本从8月到次年1月的计划，最终拖到2020年10月才上线，整个过程超过两年。
两位创始人都有分布式系统经验，却低估了开放式、无需许可的协作难度。分片带来了路由和数据可用性问题；他们实现了大概5种共识设计。Illia说，他们曾让最初的Avalanche设计失去活性，并指出Avalanche此后已有很大变化。他们的Whiteboard Series也延续了这种做法：工程师深入讲解机制，让缺陷——包括Loom的退出博弈机制——有机会在镜头前暴露出来。
3. 链抽象将消费应用与NEAR买盘连接起来
Avi质疑基础设施能否真正做到对消费者友好。Illia从2019年说起：他们采访了约300家加密公司，也亲自测试新手上手流程。从一台新设备买入一只CryptoKitty，要走92步、花12小时；按他的说法，流失率高达99.99%。更好的钱包、更顺畅的引导流程和元交易，可以免去用户先买Gas才能使用应用等步骤。
这套思路后来发展为链抽象：把用户限制在一条链上，就像要求Netflix用户为了看存放在另一台服务器上的视频，先换一种货币。使用Intents时，用户只需说明想要的结果——例如把10 ZEC转入一个屏蔽地址，资金来自Solana上的USDC——再由求解器选择路径。Avi问这是不是不过是桥，Illia回答，求解器可以用LayerZero、Binance，或任何能实现目标的方式。
等了很久，没等到别人把消费端体验做好，NEAR便在2月的NEARCON上推出near.com。Illia介绍，用户可以用Face ID或指纹登录，管理包括Bitcoin和Zcash在内的资产，还能支付、兑换、买股票、交易perps和使用Earn，不必来回切换钱包或操心Gas。其私有NEAR分片运行在安全隔区内，加密交易在其中解密并执行。他把私密交易、再跨生态支付称作“流动中的隐私”。
Illia称，Intents月交易量约40亿美元；near.com按周贡献10–20%。协议会按资产收取不同费用，稳定币费率较低，费用会转换为NEAR。perps和Earn也会拿出部分费用用于回购。Avi追问累计买入了多少NEAR，Illia没有给出数字，只指向revenue.near.org，并称：“每款产品实际上都在创造收入，然后回购NEAR。”
4. 智能体商业瞄准企业间的交易摩擦
Avi提出更大的质疑：给AI智能体一个Ethereum私钥，它不管底层是哪条链，本来就能交易——AI与区块链结合的独特之处在哪里？Illia承认，没有区块链也能做生意。他提出的分工是：“AI是前端，区块链是后端”（AI is a front end, blockchain is a back end）：智能体寻找交易对手并谈判，市场负责执行交易。
一个具体设想是让智能体安排向洛杉矶港交付50吨钢材，并由托管与争议处理机制提供保障。Illia认为，企业之间缺乏信任，催生了律师、冗长协议和反复修订条款；区块链轨道可以减少这些摩擦。他最初把市场规模描述为每年20万亿至50万亿美元，之后又称，他认为AI能够将20万亿至40万亿美元的经济活动搬上链。
他划定的边界是企业关系，而非买菜：消费者购物已经高度优化。NEAR的智能体市场先从数字工作切入，因为结果更容易验证，再逐步扩展到更广泛的商业活动。雇用智能体还带来隐私要求：如果智能体运行在别人的机器上，用户的交易关系和私人信息就可能暴露。
5. 推理来源验证与支出策略，分别应对智能体风险
Illia对推理风险的描述很具体：API端点可能换成更小或量化后的模型，也可能伪造工具响应，指示智能体运行一条Bash命令，感染机器并窃取私钥。他说，路由服务和免费模型尤其有这类风险，部分实际服务商也不例外。Avi认为OpenAI会设置安全防护；Illia则说，漏洞出在智能体及其使用的端点上。Hermes接入任意API时，“你根本不知道后面跑的是什么”。他还提醒，浏览互联网、阅读新闻也可能成为攻击入口，并称NEAR为此设有攻击测试平台。
Illia称，Near ID会提供签名后的来源证明，标明GPU、准确的模型版本、软件哈希，以及每个转发流量的节点。他将其称为“端到端的可验证性与隐私保护”。去中心化获取GPU也是另一项好处。他还看好算力市场：用区块链市场取代如今供应商之间双边砍价的模式——比如询问两个月后是否有算力、再比较不同报价。
near.com计划推出的金融智能体，还会增加一道独立控制：由策略引擎约束执行，超出策略范围就必须获得明确批准。Illia把它比作聘请一位受限额约束的资金管理人，而不是把每一块钱都交出去。用户可以授权智能体采用迷因币策略，但智能体不该擅自选择这种策略。这套策略系统也会作为开发者产品，供其他应用使用。
6. BSC漏洞事件加速全系统验证
谈到上周的漏洞攻击时，Illia称，NEAR Intents使用的一条BSC连接损失了380万美元。Shield发现异常后，团队暂停系统并打上补丁，1小时内恢复上线。他介绍，Shield会扫描NEAR和其他链上的异常活动及疑似洗钱行为。他说，团队的担忧始于Bitget遭黑客攻击一事，当时朝鲜实际上试图转移资金。
Illia称，Shield的数据随后帮助他们确认了攻击者：“钱全追回来了”，实现“100%追回”，攻击者还在链上道歉。Avi追问这条连接是否由NEAR工程师搭建。它来自一位生态合作方，但Illia承认，“测试没有达到我们本该达到的标准”。
团队将加快对整套相互作用的合约进行形式化验证，同时加强监控。Illia称，相关工作此前已经开展数月，并声称他们在多个基准测试中排名第一；他还称，与其所说的“使用OpenAI，比如Sol或Astra”相比，验证成本降低了100倍，但转录稿中的比较对象并不清楚。
7. 从客户出发做分发，按结果收费
Avi直言不讳地提出了市场进入难题：过去有过技术很强却没能成功的项目，即使开发者是图灵奖得主也一样。Illia称，NEAR现在采取“销售优先”的方式，在动手开发前先寻找客户或设计合作伙伴。
分发渠道包括Trust Wallet、Ledger、LI.FI和SwapKit；Shield的合作伙伴包括Binance和ZeroShadow。Illia称，Venice使用NEAR提供端到端加密模式，Brave则把NEAR列为其智能体的一个选项。还有机器人公司在后端使用NEAR进行推理和智能体工作。
一个来自非加密、非AI领域的案例，是Philosophia的场地寻找智能体。该公司积累的内部数据库，可以回答“在新加坡为50人安排一场机构侧边活动”的需求，省去发邮件和员工翻找记录的过程。产品把数据库与智能体结合起来，按结果收费——也就是实际预订到场地。Illia将其视为对现有商业关系的自动化。
Illia最期待的产品，是在用户现有near.com资产上运行的金融智能体。更长期的目标是让智能体市场从数字任务扩展到有偿的现实世界行动：“按结果付费”（paying for outcome），最终把“真实GDP”（real GDP）搬上链。
完整逐字稿
There’s no guarantee they’ll respond with a real model response. They can use a smaller model.
Okay.
They can use a quantized model, or they can just insert completely fake output.
Hmm.
For example, they can run an arbitrary Bash command, and that command can infect your machine—
Hmm.
—with a virus, and—
Okay.
—steals all your private keys, for example.
Right. That wouldn’t be great, but you’d assume OpenAI would have safeguards against that.
But it’s not on OpenAI’s side. This is on your agent’s side.
Okay. Understood.
So if you’re running, let’s say, Hermes, and you point it at an API endpoint, you have no idea what’s running behind it, right?
I see where you’re going.
This is where the verifiability of blockchain technology is very useful. You want to know exactly what’s running there.
Guys, we have such a special guest here today. We have the founder of NEAR, Illia, with us at TOKEN2049, and we’re about to dive in and talk about everything you need to know about him: his past, his present, his future, and what NEAR can do for you and for us. Thank you for joining us.
Yeah. Let’s go.
So, take us back to the start. You were born in Ukraine. You’re sort of a math genius, as far as I can tell. Take us through your early days. Were you always interested in this area? Talk to me about your high school and college.
There are a few things that were pretty formative for me. One is Ukraine, the former USSR. My grandparents spent most of their working years in the USSR, and one thing I distinctly remember is that they had this savings book from Sberbank, the USSR’s main savings bank. They had some savings there that, effectively, when the USSR disappeared, weren’t worth the paper they were printed on.
Wow.
All the savings just disappeared when the countries split. When Ukraine separated, it actually had a different currency from the one it has now, and what happened was complete hyperinflation. I remember going to buy bread, and over the span of a year, I think the price went up 100 times.
Wow. So you actually waited in Soviet bread lines?
This was already Ukraine.
This was post-Soviet. Okay.
This was Ukraine, yeah.
It wasn’t a bread line; capitalism had already started working.
Yeah.
The currency didn’t work yet, right?
Okay, fair enough.
The country just printed the currency.
Yeah.
Effectively, it hyperinflated.
Oh, God.
It cost 1,000, 10,000, 100,000 for a loaf of bread. Those are fundamental memories for me of needing a store of value and decentralized money overall. I also remember watching A.I. Artificial Intelligence when it had just come out. The movie itself is kind of separate, but the concept gave me an understanding of the idea. I read a lot of science fiction, like Asimov and Heinlein, and I always thought artificial intelligence was how we would solve the world’s problems.
And what year was this?
This was around 2000.
Wow. So this is—
The movie came out—
—very early, before anything.
Yeah, I was 10 years old.
Right.
Right.
When I was 14, I was participating in competitive programming, and a lot of what you do is practice. You solve a lot of problems. I thought, “Why am I doing this? A machine should write this code.” I really believed, from when I was 14, that we were going to automate coding with AI. I started trying to build my first neural networks in high school. My math wasn’t there yet to do that really well, but I went to college to study applied math and learn more about machine learning. I also started working in my first year for a machine learning company, remotely. Their main office was in San Diego.
What did a machine learning company even look like back then? What types of things were being worked on?
The things we were working on were pre-neural networks, so decision trees. The main clients were banks and insurance companies, so it was credit scoring and different kinds of risk, including life insurance—predicting people’s average life span. We had all kinds of fun projects. One was with an oil company that gave us drilling data from a field, and we needed to find oil.
And you can do that with—
There’s underlying data about the soil and—
Right.
—its penetration. You build a model that can explain that from the data—
Are these not just—
From the drilling data.
—like, simple linear regressions at the—
No, this is—
Or is this more complex?
This was gradient-boosted decision trees.
Okay.
There are thousands of decision trees. A decision tree is like: if this feature’s value is 5, or if this feature is above a certain value. For credit scoring, if the income is above $100,000, you’re more likely to return the money, and so on. There are all these features. You can build these trees pretty deep, and they can explain a lot of things. Then you build a lot of them, too, so it was pretty sophisticated machinery. The company I worked for was one of the first to do decision trees, period, in the ’80s.
Wow.
That company was from 1970. Anyway, that was my first experience. Then, when Google published the paper—I forgot the name, but it was effectively the cat neuron—the model was shown a bunch of internet pictures. It needed to compress information and uncompress it, and it learned that there was a thing called a cat without ever being told that.
Right.
That was a paper from 2012 or 2013, by Jeff Dean and Andrew Ng. It was literally the first time that, at pretty large scale, they were able to do unsupervised learning, which is what everybody’s doing.
What was really the key to unlocking that? What was the advancement that was made?
The advancement was the work of Geoffrey Hinton and Yann LeCun. They effectively got multilayer neural networks to work with backpropagation—the training started to work. All of these things were known before; they just didn’t work. It was a combination of the math being worked out right and the compute being there. That’s generally been the story. If you look over the past 30 years, it’s effectively the same ideas people thought about before starting to work when the compute catches up. That was the first time. That specific paper was trained across, I think, 600 machines, which was a lot at the time. Now it’s like, “Eh, 600 machines? What is that?”
Yeah.
Back then, it was a really big model.
Right.
This was the first result of actual unsupervised learning, and I thought, “I want to do that, but on language.” There are thousands of species in the world that can see and understand images. Flies can see, so clearly that’s not a measure of intelligence. The way we measure intelligence in people is by asking questions, right?
Right.
What you’re doing right now.
Mm-hmm.
So let’s just do that. I joined Google specifically to work on question answering and understanding language using deep learning. The idea was that deep learning would be the way, and natural-language question understanding would be the direction. Google was a great place because there’s lots of natural language. They index the whole internet, and people are asking questions all the time, so there’s a direct product.
As part of this, we were building interesting models already back then, but they were all too slow. The concept was called a recurrent neural network. Humans read one word at a time, but that’s too slow. If you ask Google a question, you don’t want it to read for 10 minutes before answering.
Right.
So the problem was—
Is that also a compute issue, or is that—
It was a—
—a model issue?
It was a problem with the algorithm, right? It would read one word at a time. If you give it 10 pages of Wikipedia, it would need to read one word at a time, and that would take some time. Our first approximation was, “Let’s just take every paragraph, sum all the words in it, and answer from that.” It kind of worked, and—
How do you sum a word?
Every word gets projected into a multidimensional space, so it becomes a vector. Every word gets replaced by a vector, and then you can sum all the vectors. You get an average of the meaning of all the words.
And it doesn’t strip out the meaning of—
If you train it properly, you can get some results.
Okay.
That was actually the first question-answering model in Google.com. When you asked questions, it was already showing some answers back in 2015 or 2016. It was a very simple model, but it was very fast.
The idea behind the Transformer was to take that a step further. The reason it’s fast is that all of this can be done in parallel. You project every word into a vector in parallel, sum them up, get the answer, and score it. The idea with the Transformer is: What if we do that, but use a more sophisticated way of extracting meaning, and do it multiple times?
We take every word and look at them in parallel. We use an attention mechanism, which effectively looks at every other word for each word and tries to make sense of it. If you do it once, you link words pairwise. You can see how every word is related to every other word, but you don’t get multiple levels of inference or conclusions.
If you do this process multiple times, each layer of the Transformer transforms the meaning of the original sentence into an answer to the question. Very simply, take “The cat sat on a wall.” “Cat” and “wall” don’t connect in one link, but “cat” and “sat” do: the cat is sitting somewhere. Then the next layer can link “cat sat,” as one concept, to “wall,” and now you have “The cat sat on a wall.” You need 2 steps to make sense of that interaction.
Now, every token in a reasoning model is one more step of interaction it can make, and one more step of thinking it can do. Back then, we didn’t have that. But the idea was that, compared to a recurrent model, where you read one word at a time and try to make sense of things in order, here you can massively parallelize the process. You can use GPUs, which have thousands of cores, to process everything in parallel. Now you can train and answer questions extremely quickly.
I use an example from the movie Arrival to explain this—
It’s actually one of my favorite movies of all time, and it has one of the best soundtracks of all time. There’s a song called “On the Nature of Daylight” by Max Richter that’s amazing. But anyway, sorry. Total tangent.
Spoiler alert if you haven’t watched it: the aliens project their communication as one continuous message. The idea is that there’s effectively no beginning or end; it’s all encoded in one thing. You can think of Transformers as being kind of like that. They don’t really read the beginning or end of a sentence. They read the whole thing in parallel, at the same time.
I understand. This might be a very stupid question, but with the Transformer itself, you talked about the relationship between “cat,” “sat,” and “wall.” Let’s say that relationship is established. Is it saved somewhere and then referenced in the future in these models? Or is it always reasoning from first principles, and it’s just good at doing that reasoning, so it can do it quickly?
That’s a great question, and this is what’s called the KV cache.
Okay.
As this processing is being done, so-called key-value storage is being created in the model. For a key, let’s say “cat,” it will store that the cat sat on a wall as a concept. Whenever you ask a question later, like, “Where is the cat?” it will look up “cat” as a key—
Right.
—and find that it sat on a wall, and answer that. That’s why there’s this concept of a KV cache. If you have the KV cache stored as you’re processing, it’s cheap to retrieve it. If you don’t have it stored, you need to recalculate all of this again.
Right, that makes sense. And so this paper was foundational, but for what purpose? To what end? What sprung out of this?
What sprung out of it is that it solved a couple of conceptual problems that existed in deep learning, especially for language. One was that recurrence was really hard to train before. If you had models that read one word at a time and you gave them hundreds of pages to read, they’d kind of forget everything from the beginning by the end.
Right.
So you solved the problem of forgetting things, and you solved the problem of training performance as well. It was slow to train because if a document was long, it needed to read one word at a time. Your utilization of accelerators, GPUs or otherwise, was also very low, because you only did one step at a time.
Here, you could leverage as many GPU cores as possible to process in parallel. That solved the idea that we could throw more compute at it and train bigger models on more data. We could also train it to read more and more things and think through longer contexts.
Another area: Ilya Sutskever at OpenAI effectively said, “Let’s scale the hell out of this.”
Yeah.
That’s where they got GPT-1 and GPT-2: bigger and bigger models that started to show more and more reasoning capabilities. Then we got ChatGPT.
In parallel, from a research perspective, the same model architecture worked on images, sound, video, and everything else. It actually worked really well in effectively every domain and started becoming standard for a lot of models. A lot of machine learning became just using that.
Honestly, I could talk about this forever. This is very interesting to me, and I’ve never really dug into the models like this before. But I do want to talk about how you came to found NEAR. You were super deep in this world of AI, writing this incredible paper, and contributing to the foundation of what is now a massive industry. But at some point, you decide, “Okay, I’m done with this, and I want to go into the world of blockchain and build a highly performant blockchain,” or however you would describe NEAR. We can get into that.
The story was the following: I was already planning to leave Google when I was working on the Transformer. When I left, my co-founder Alex and I always had this idea, as I said, that computers should write code.
Mm-hmm.
Even in 2017, the vision was: Look, if computers write code, it effectively flattens the whole computing space. We don’t need hundreds of applications. We don’t need SaaS or all of these things. We’ll just tell the computer what we want, and it’ll do it.
In 2017, this sounded ridiculous. People were like, “You’re crazy.” But we raised a little bit of money and started building this, and we had some initial results. We used Transformers and trained them on GitHub.
Mm-hmm.
We effectively did all the same things, but we had very little compute power, so our models weren’t that big. What we tried to do was collect a lot more training data.
We had students, computer science students in Eastern Europe, Southeast Asia, and China, who would do small tasks: write some code for a description, write comments for the code, explain it. We had trouble paying them. Chinese students didn’t have bank accounts; they used WeChat Pay. In Eastern Europe, every country had a separate system. PayPal didn’t work there, Payoneer didn’t work there, and Wise didn’t work there. Southeast Asia was the same.
So we stumbled on crypto as a way to pay people. We asked, “What’s the easiest way to pay people globally?” Crypto was supposed to be that: a global payment network. But this was 2018. CryptoKitties had happened, and Bitcoin prices had been high for a moment. In reality, none of it worked. The transaction fees were higher than what we were paying people.
We thought, “Okay, there’s clearly an opportunity here.” With AI, compute wasn’t there yet. The GPUs literally weren’t there yet to scale what we needed. So we thought, “Okay, we’re going to go build the blockchain quickly. It’ll take 6 months. That’s pretty easy. Then we’ll come back to AI.”
Six months?
Yeah.
Really?
Our original pitch was, “We’re going to start in August and ship it by January.”
Who exactly were you pitching on this?
We raised some more capital from Naval Ravikant, MetaStable, Accomplice, and a few more investors. Obviously, the team as well—we brought in more engineers to work on this. The idea was that we should have a blockchain that’s easy to use, consumer-friendly, and where transaction prices don’t go up when more people use it.
That’s an important one.
Yeah. It should be cheap to use because we wanted it for microtransactions. Those were the inputs. The output was that it needed to be sharded, account-abstracted, and built on WebAssembly, so you could write in any programming language you wanted and it would just run.
Mm-hmm.
That’s what gave us the initial starting point for NEAR. We were a little too optimistic about how long it would take to build.
How long did it end up taking?
We launched in October 2020.
Okay.
A little over 2 years.
What were the hardest problems to solve?
There were 2 conceptual problems. One was sharding. We had some ideas about how to do it, but when we started implementing it, there were a lot of complications around how to route data and make sure there was data availability.
Alex had built a sharded database company before. He was engineer number 1 at SingleStore, which is used by Fortune 500 companies. I’d built distributed systems at Google, but we hadn’t built permissionless distributed systems. We didn’t fully understand how complicated it was to make sure the security and financial infrastructure worked right off the bat.
The other interesting problem was consensus. We ended up implementing about 5 different consensus mechanisms, everything from Hashgraph. We implemented a version of Avalanche and broke it.
You broke it?
Yeah. We have a blog post where we effectively broke the liveness of the Avalanche consensus at the time.
Okay.
They’ve changed a lot of what they’re doing now. But with the original Avalanche paper, we had a way to effectively prevent liveness. It required very little—not even stake, just the number of computers in a network.
We ended up building a lot of different consensus mechanisms, testing them, and breaking them. That’s when we started the Whiteboard Series. We have a YouTube series where we interview other blockchains—
Okay.
—protocols. Our mindset was to ask the kinds of questions a very smart blockchain engineer would want to ask to understand why a protocol works. That also means we broke multiple protocols on the Whiteboard, on record.
Can you name them?
The specific one that really doesn’t exist anymore is Loom.
Right. I totally forgot about Loom. What a blast from the past. That thing—yeah.
We had Georgios, who’s CTO at Paradigm and Tempo now. He was working at Loom at the time, and we effectively broke their exit game on a Whiteboard. He was like, “Oh.” It’s a pretty fun episode.
I’m going to have to check that out after. And so—
There are a lot of different ones. A lot of the ones we broke and interviewed don’t exist anymore. We helped fix some of them as well. We have a bounty for fixing Solana, too.
Mm-hmm.
Yeah.
That’s good.
So—
It’s always good if a founder of a blockchain is able to break others, because hopefully that means they haven’t been able to break their own.
Exactly.
And that’s good. But I want to talk about NEAR today. You said that you wanted it to be a consumer-friendly blockchain, right? I think sometimes, to me, that’s a little bit of an oxymoron, because you’re providing the infrastructure for other people to build applications, right? At the end of the day.
That was the core idea: we were going to build the infrastructure, but make it easy for applications to create a consumer-friendly experience. In 2019, we interviewed—I think our CRM had 300 crypto companies. That was probably all the crypto companies that existed at the time. We talked to them about user experience, developer experience, and the challenges they had.
Everybody said onboarding was a problem. We actually tried it ourselves: here’s a new machine, buy a CryptoKitty. It took 92 steps and 12 hours.
Yeah.
The drop-off rate was 99.99%, even if people wanted to do it. So what did we need to do to solve that? The wallet experience needed to be smoother, and onboarding needed to be smoother. You needed to have meta-transactions, so you didn’t need gas. You can build all of these things at the protocol layer to make it easy to build consumer-friendly applications.
Is that where you are today? Where is NEAR today in terms of application usage?
That was the original thinking. I think we’ve really evolved since then, because a few conceptual things happened. One was the realization of what we now call chain abstraction. We made NEAR easy to use, but there are applications on other chains. It seems strange that we’d limit our users from using other applications. It’s like saying you can only use what’s hosted on AWS.
I use this example: you watch a Netflix video, and then you want to watch another one, but it’s on a different server, so you need to pay in a different currency.
That would be very annoying.
Yeah. So first, we had chain abstraction, and we built the chain abstraction stack. This is actually where NEAR Intents started to come in. From a broader perspective, what people want is just to achieve some outcome.
Mm.
They want to say, “I want to earn this percentage in this Morpho vault,” or, “I want some Zcash,” or, “Move some Telegram USDT to TRON USDT and pay for some service.” That’s the high-level intent. We can talk about how this translates into AI and agents as well, but this is very hard and complicated. As soon as you touch multiple chains, it becomes super complicated.
How is it different from LayerZero or a bridge? Or are you just building bridge infrastructure?
I think the main difference is in how users think about it. If you think of it as a bridge, then as a user you need to figure out, “I need to bridge, I need gas, I need a wallet, I need all these things.” We said, “Actually, you just describe the outcome, and our solvers—effectively, agents—will find the best way to do it.”
Okay.
They may use LayerZero, Binance, Nasdaq, or whatever needs to be done to achieve your outcome. It’s really changing the model from a transactional one, where you prescribe how to execute an action, to one where you say, “I need this outcome. Execute. Make it work.”
My mind doesn’t work in abstraction, so I need an example.
Yeah.
When you say—
Well—
—you describe it to your solvers—
Yeah.
Who’s describing it, and what are you describing?
As a user, I want 10 ZEC in this shielded address that I have. I have Solana USDC, and a solver can come in and say, “Cool, I’ll figure out how to get it to you.”
But you’re going to a website, you’re doing—
That’s where we first built the infrastructure to do this. We plugged it into Zengo Wallet, Trust Wallet, Ledger Live, MetaMask, and all of these places. A lot of the current wallets, when you’re doing trades, swaps, and bridging, are actually using NEAR Intents underneath.
Okay.
At the beginning of this year, in February at NEARCON, we launched our own product called near.com. Coming back to consumer-friendly experiences, we waited for somebody to build one and eventually decided to build our own.
Okay.
Now you can go to near.com and log in with Face ID or your fingerprint. You can hold all your assets across Bitcoin and Zcash in one place, with no gas fees, multiple wallets, or addresses. You can pay, swap, hold stocks, trade perps, and earn, all in one place. Importantly, everything is private. That’s another transition we’ve made.
How is it private? How did you—
We launched a private shard of NEAR. It runs inside secure enclaves, meaning there’s no way to physically access what’s happening there. You send encrypted transactions into it; it decrypts them inside, executes them, and there’s a way to query your state through the front end. The benefit is that we can have privacy in motion: you can make payments, trade equities, and easily pay out to a TRON, Solana, Base, or Ethereum address when you need to. It’s connected to every other ecosystem in an easy way.
Now you have a consumer-friendly, fully chain-abstracted wallet. There’s no switching networks, adding RPC endpoints, or topping up gas. None of that exists. It’s a smooth, fully on-chain consumer experience.
How much volume are you running through this now?
We’re doing about $4 billion a month in NEAR Intents overall, and near.com accounts for about 10% to 20% of that, depending on the week.
And of that $4 billion, how much is being generated in fees for the NEAR blockchain? What impact does that have on the NEAR token itself?
The protocol takes a fee. It depends on the assets: you don’t take as much on stablecoins, while some assets have a higher fee. That all gets converted into NEAR.
So it gets converted—it’s sold into NEAR, so that volume eventually translates into buy pressure for NEAR?
Correct.
Do you know how much NEAR has been bought to date through that?
There’s a revenue.near.org dashboard that shows—
Okay. We’ll take a look.
Yeah. I mean, effectively, last week—
We’ll put the number right here.
Yeah, let’s do that.
Editing post is magic.
Exactly. We’ve seen massive growth in both revenue and our take rate on volume as we build more products. Perps are growing too, and we take a percentage of the perp fees and use it to buy back NEAR. It’s the same for Earn. Every product effectively generates revenue and buys back NEAR.
It sounds to me, though, like NEAR has gone from being a blockchain to almost a fintech app.
The way I think of NEAR is as a vertically integrated stack for the AI and blockchain future. We didn’t touch on AI, right?
No. Well, yeah, we—
We’ve been building out the fintech side, but at the same time, we’ve launched—or relaunched—NEAR AI. The thesis is that AI is a front end and blockchain is a back end.
Mm-hmm.
More specifically, your AI agent is going to be the front end, and the market’s infrastructure is going to be the back end. As we spend more and more time with our agents, those agents don’t really communicate with each other or transact with each other. But if they could create a universal market, they could say, “I need to book this room,” or, “Let’s deliver 50 tons of steel to the Port of LA because we need to produce something.” That’s effectively an intent. The intent can then find a counterparty agent that will execute it. You need money in escrow to execute this, and you need a way to resolve disputes.
It’s effectively the same infrastructure we’ve been building for cross-chain, but generalized to all kinds of commerce and actual business transactions, with a total addressable market of $20 trillion to $50 trillion a year. That’s really where we’re going. It starts as fintech because that’s the easiest thing for us to verify, plan, and transact.
We already have an agent market where you can have agents transact with each other. It starts with digital work because that’s easier to verify, too. We have private AI to back it up, so you don’t leak all this information when you hire another agent. If that agent runs on somebody else’s machine, they could get all your private information: what you’re doing, who you’re trading with, and what information you’re sending. So you need private AI to verify it as well. We also have an AI inference business running.
Is that similar to Venice?
Venice is using us for its end-to-end encrypted mode.
Venice is using—
Yeah. Brave also has an agent, and they’re using us as an option. Other companies, including robotics companies, are using us on the back end to power their AI inference and agents. We’re going to launch your financial AI agent in the near.com consumer product, which is fully private and operates on top of your existing assets.
One thing I always struggle with is the concept of AI × blockchain. What does that even mean? When I think about it, if you give an AI agent access to a private key for an Ethereum wallet and ask it to perform certain actions, it should be able to do that regardless of the underlying blockchain infrastructure. That’s more on the AI side than the blockchain side. These agents are capable of doing basically anything you want them to do on a computer.
So what I’m struggling with is, why are people talking about AI × blockchain? Is it not just a matter of getting blockchains integrated everywhere? Every hotel will have a wallet, every person will have a wallet. Why is there this overlap? What makes it so interesting?
There are 2 sides to this. One is decentralized privacy and verifiability. If your AI consumption still goes through OpenAI, OpenAI can effectively respond to you with arbitrary stuff. Your agent—this is happening right now. If you’re using routers and maybe free models, especially, but also some actual providers, there’s no guarantee they’ll respond to you with a real model response.
As opposed to a fake model response?
They can use a smaller or quantized model, or they can insert completely fake output. For example, they can run an arbitrary Bash command, give a tool output back saying, “Run this Bash command,” and that command infects your machine with a virus.
Hmm.
—and steals all your private keys, for example.
Okay.
That wouldn’t be great, but you would assume OpenAI would have safeguards against that.
But it’s not on OpenAI’s side. This is on your agent’s side.
Right. Okay, understood.
If you’re running, let’s say, Hermes, and you point it at some API endpoint, you have no idea what’s running behind it.
I see where you’re going.
This is where the verifiability of blockchain technology is very useful. You want to know exactly what’s running there, and that’s what Near ID provides. Near ID provides full provenance: exactly which GPU it was run on, with the exact software, the exact model hash, and the exact software hash. You get a full signature on everything you run, as well as on all the nodes that routed your traffic.
Mm-hmm.
This is full end-to-end verifiability and privacy, so you get both in one. That’s one aspect where blockchain technology is really useful. You can also decentralize GPUs, because it’s been really hard to get access to them.
Right.
You want them everywhere. The second part is markets. The way the compute market works right now is like, “Hey, you’ve got some GPUs. What about in 2 months? Can you give me a better price?” “I have a better price from this guy.” Blockchain is extremely useful here because it opens up a market for something that’s very liquid but kind of hard to move. That’s another aspect of blockchain and AI.
Finally, the third one is agent commerce. Yes, you can give a private key to your agent and it can do transactions. You probably should not do that.
Right.
On top of what I just described—how to attack your agent through an AI endpoint—there are also ways to attack your agent by having it browse the internet and read news. We have an attack bench for exactly this.
By being hooked up to conference Wi-Fi as well.
Yeah. Well, that’s a whole separate thing. Unencrypted Wi-Fi is—
But that’s fair. I do want to understand a little bit. There was recently some concern over security. There was a recent hack that I want to give you some time to address. Basically, what happened?
Yeah. Let me finish on the generic stuff, and then we can talk about the hack and other things. Agent commerce is critical, I think.
Mm.
You can do a lot of commerce without blockchain. You can still wire money with bank accounts and do transactions. But especially when we talk about actual business commerce, there’s no trust. That’s why we have long legal agreements between businesses, lawyers involved, and lots of back-and-forth redlining. Businesses don’t actually trust each other when they do transactions.
Yeah.
This is where blockchain is great, because you can have money in escrow, you can have derivative contracts, and you can do all kinds of interesting things to create smooth economic transactions. You can remove a lot of the throttling that this lack of trust creates through legal systems, and have a faster money economy.
AI can be the front end—the negotiation, finding the partner—and blockchain can be the rails, the back end, the markets to execute those business transactions. This is where I think $20–$40 trillion of the actual economy comes on-chain with AI. That’s the opportunity. It’s not consumers getting their agents to buy groceries. That’s not much of an improvement, and that part is already super optimized for the consumer experience. It’s actual business-to-business commerce relationships. That’s why everyone’s talking about AI, blockchain, and agent commerce: that’s the big pie to crack, and how we’re actually going to bring the economy on-chain.
Mm-hmm.
Now, fast-forward to last week. Because NEAR Intents is processing so much volume, and a lot of it is cross-chain, we’re continuously under scrutiny from malicious actors trying to launder money through NEAR Intents. It started with the Bitget hack, where North Korea was effectively trying to move money around. We have a system called Shield that’s actively scanning for outliers and trying to figure out if something is going wrong, both on NEAR and on other chains.
We’re trying to stop liquidity from going through our systems if we think it’s coming from hacks or other things. Bybit was in the news, and then, as part of this, there was an attack on NEAR itself. One of the bridges—a link we have to BSC specifically—was exploited for $3.8 million. They were able to withdraw the funds by continuously routing things. Shield detected it, we paused it, and we were able to patch it. We got all the systems back online within an hour.
Because we have this Shield system that ingests a lot of data, the team was able to investigate and cross-link the attack to the person who executed it. We were able to communicate, “Hey, return the money.”
Oh, so you found them?
We found them, and we got all the money back. So, 100% recovery. They apologized on-chain as well.
They apologized?
Yes. There was a very apologetic message saying, “Use bug bounties when you find vulnerabilities.”
Interesting. But the link you had with BSC is something that was built by your engineers?
This specific link is from one of the ecosystem projects we’re using. We have a lot of chain integrations, so we’re using a few different partners to do this. This was one of the partner chains. The link itself wasn’t tested to the level it should have been.
As a lesson from this—and something we were already working on, but are accelerating now—we’re formally verifying the whole infrastructure. We’ve been working on this for months. Our formal verification system is number one right now on multiple benchmarks because we managed to decrease the cost of formal verification by 100x compared to using OpenAI, like Sol or Astra.
We’re going to use this to formally verify not just every individual contract, but the whole system of contracts, because there are many involved. We’re going to publish more and more about that, as well as increase how we monitor and detect outliers.
Okay, understood. I also want to get a sense of—You’ve laid out this picture of a massive market to capture with agentic commerce, and I think a lot of people are interested right now in the financial infrastructure being built. But one thing we’ve learned in crypto is that it’s not enough to have good technology. You have to have a go-to-market strategy, good partnerships, and bring people into the tent.
What’s your plan for making sure that happens? There are projects built by Turing Award winners that didn’t really go anywhere because they didn’t manage to get people on the same side as them. Do you have any partnerships coming up? Any tactics? What are you thinking?
Broadly, there are a few different layers to this. One is that NEAR Intents has already been partnering with everyone in the crypto space.
Mm-hmm.
As I said, it’s in Trust Wallet and Ledger, and we’re working with LI.FI and SwapKit, as well as a lot of applications. The Shield system we’re building is also partnering with Binance and ZeroShadow. At every layer, we have a lot of partners who are either contributing to us or working with us to create this system.
We also generally approach this sales-first. We try to find customers or design partners to build a product before—
Mm-hmm.
—we actually go and build a spaceship in a vacuum. For the agent specifically, we've been building this by partnering with non-crypto, non-AI companies. For example, in the agent market, as I said, the first use cases are digital work. One interesting use case has been event companies that want to offer their services digitally, for example, to find venues for events.
Okay.
They have an internal database with lots of venues and—
And which company is this?
Well, one of them using it to offer their services is Philosophia.
Okay.
They've been doing events across Web3 and more traditional tech. They put not just their database, but a database plus an agent that you can ask, “Hey, I need to organize a side event in Singapore around TOKEN2049 for 50 people, institutional.” And it’s like, “Okay. Well, here are a few venues that might be interesting.” That’s because it leverages their internal database that they’ve collected over the years. Normally, you’d need to email them and have someone scan through this database—
Right.
—and do this. Now you have an agent doing it, and you charge per outcome, for actually booking that venue—
Right.
—for this. So this is a specific example of turning something that traditionally was a very manual commercial relationship into a fully automated agent market.
As we’re wrapping up, what are you most excited about in the next month, 3 months, 6 months? What are you excited to show the world that you’ve built?
NEAR.com has been extremely exciting because, as we’re adding more and more products, it’s becoming a core fintech. We’re going to be launching a financial agent on top of it that you can tell your strategy or set of actions to, and it’ll translate them into actual transactions, with security guarantees. You have a policy that controls the agent so it doesn’t try to put all your money into meme coins.
Although maybe that’s good, but—
Well, if you want that, you can approve it as well, right?
Right.
There’s an approval process and a policy engine that allows the agent to operate within a policy. If it wants to go outside of it, it needs your approval, and there’s an explicit system. Instead of just giving it your private key and letting it use all your money, it operates within this policy. It’s the same as if you hire someone to manage money: you’re not just going to give them all the money right away.
Of course.
You’re going to give them some set of restrictions first, and then they need to ask for approval. So it’s the same idea, built directly into NEAR.com, and it’s also available for others to leverage in their products. It’s a developer product as well. That’s a big one. The agent market is starting to see more and more use cases where you’re paying for an outcome, for some direct action taken, ideally in the real world. This is a little bit longer term. As I said, moving the real economy, real GDP, on-chain.
I’m super excited for that, and thank you so much for spending the time with me today. This was a very enlightening conversation.
Thank you for having me.
And, no, this is great. Thanks, guys. Nothing said on the Thousand X podcast is a recommendation to buy or sell any investments or products. This podcast is for informational purposes only, and the views expressed by anyone on the show are solely their opinions, not financial advice, or necessarily the views of 1KX Media. Our hosts, guests, and the 1KX team may hold positions in the companies, funds, or projects discussed.