NEAR at ETHDenver: One Trillion Agents - Day 1

Captions as YouTube publishes them, usually machine-generated, so product and people names can be misheard.

1. 0:00

   call and an absolute uh genius on two legs his name is B Wang he's just hydrating himself so give him a big round of applause for Mr B Wang hello hello oh stuff not working oh now works yeah thanks everyone for coming um I'll start talking about um scaling and how wise needed for uh AI agents okay so I think uh let's start from uh okay screen let's start from the um uh the world that we're living in today uh AI being like more more and more powerful and uh more and more into our

2. 1:03

   everyday life um and as result I think it's natural to project that uh in the next several years there will be more um AI agents coming up and they will be more integrated into our daily lives uh you can imagine a agents that do things like pay bills manage your Investments uh making phone calls for you and Etc so that's kind of the um I think most people would agree with like you know what's going to happen in the next

3. 1:31

   like several years um okay but why why do we need blockchain right how how is it even relevant here uh so I think there are mainly two uh aspect to this one is that uh you need a open uh Finance Financial layer that can that that allows you to uh truly Empower those autonomous AI agents um so if you look at the current Financial system today um what is lacking is like you know let's say you want to actually receive funding or you want to like uh

4. 2:04

   let's say manage the investment and so on you often need to go through a KC um for example um even if like none of those things are happening even if you just want to start a business or whatever uh that's uh kind of a necessary step and that doesn't work very well for a agents um and what would work very well is U this open and per permissionless platform where uh you know you can permissions to receive uh and manage assets another important aspect is that

5. 2:36

   uh you need a settlement layer between all of those agents that's uh neutral and also open uh so imagine like if let's say we have like you know billions or even trillions of agents and everyone has like tens of them um you need some way for them to kind of talk to each other connect with each other and potentially also setle agreements among each other maybe that's a trade maybe it's a uh it's a a financial agreement

6. 3:01

   maybe just contract something else um and you need a you need a place that allows to to do the setlement uh and you need something that doesn't really um bias towards uh some specific AI agents U if you have a company behind that is likely going to be the case Okay so uh now that we talk about uh why blockchain is needed uh why is interesting for the proliferation of AI agents uh I think uh it's important to examine what properties the blockchains

7. 3:33

   we actually need um I think scalability here is extremely important uh because you know a agents will be quite easy to create uh there'll be some simple interface to create them and as a result there will be likely a ton of them uh and if we don't have this very scalable infrastructure then um likely though you run to some problem like you know congestion and uh degradation of the experience uh and over just like won't be able to uh be the platform where like

8. 4:04

   trillions of Agents can trade and settle and and manage uh their assets uh so yeah what's uh um what's unique about near and why it plays an important role here um I think important thing is that we have this shed broad chain design from the very beginning uh and the seut scales um linearly with number of shards so as more a Agents come on board uh we can scale the broad Chain by adding more shards to cater to that need and something that's much less talk about is that we have this very

9. 4:36

   interesting feature on the blockchain that allows you to pause a transaction in the middle um and potentially do some offchain computation and then come back with the result of the computation and resume the same transaction and and you can imagine this is pretty good for uh AI use cases for example if you need to run some inference uh do some database query number crunching analytics uh you

10. 5:01

    can do that in the same transaction and just pause it there and then then transaction comes back later and resume the same transaction to the end with that said I want to talk a bit about uh what we're trying to do for 2025 uh there are two main goals for skating uh one is 1 million transaction per second and two is 200 millisecond blocks okay let's start with with the first one uh 1 million TPS um so I want to first talk about like roughly how it's going to work uh just doesn't come

11. 5:33

    out of nowhere uh so the idea is that we have we have a sharting from there beginning and uh since we launched n 2.0 last year system is fully shed so basically if you add more shards then you'll get more throughput and you can roughly think of the seut as the uh seut of uh the number of shards times the seut per Shard um and you know we can imagine a world where we have 50 shards then you know if we have 20K TPS per

12. 5:58

    Shard then that gives rise to roughly 1 million TPS so what do we need to get there uh so one thing we need is like actually to to get to let's say 50 shards so today we have six shards on Main um you know how do we get to 50 shards so it's through this mechanism called rearing so basically this is a very effective efficient way in the protocol to split uh one charge into two sharts based on some boundary account right so let's say

13. 6:27

    we can um let's say we have chart where it's um includes all the account from Aris near to Bob near uh to split into two uh two shs let's say with sprit uh we determine somehow that the boundary is bat or near uh then the sprit can be from Alice near to B near and then from b. near to bob.

14. 6:49

    near um and uh because of the stus validation set up that we have today we also need the rearing to finish in one block uh so that it can actually um people can actually validate validators can actually validate the state transition uh so uh it's a pretty complex uh heav lifting and uh I won't go into the lot of the technical details on how exactly that works uh but surpris to say that now we have this mechanism and it's going to go out to main net next week uh so in this release we're

15. 7:21

    going to split um two of the shards and into two uh so we're going to increase from six shards on Main not into h shs on Main net uh release is going to happen next week uh and then U so that's kind of The Shard uh how you get too many shards but also uh that's not enough you also need to um you also need each Shard to be very performant as well um so there are a couple of uh important uh optimizations that we're working on uh one is is optimistic runtime execution uh so this is kind of to wrong the

16. 7:56

    execution in parallel with the code that actually validates the transactions are valid um today is they're wrong sequentially and that actually just eats up a lot of time when you have let's say 10,000 transaction uh that all needs to be applied uh and the other one is actually the parallel execution of transactions and receipt uh so actually our WR time because already asynchronous um all the receipts of taring different accounts can be parallelized without

17. 8:22

    worrying about the the outcome so the order doesn't actually matter uh there what matters is um the order of rece is touching the same account uh so we can leverage that and effectively paralyze our own time okay so uh let's move on to the to the next scope which is 200 MC blocks uh just to give some uh background information on like you know where we uh how how we arrived to this go uh so when we released the N 2.0 uh last year uh we

18. 8:52

    actually dramatically improves the single sh processing speed because we require all the node uh to to run the chunk application uh to have the state in memory so when you they apply a chunk uh all the state is already loaded into memory so you don't have this um performance problem where like some database reads might be super slow uh so it already become much faster and also much much more stable uh we didn't have

19. 9:17

    we didn't change uh the block time at the at the time of the release because we we want to see how it goes first uh making sure that um it's stable uh and everything works properly uh so with a number of optimizations with down sying St we are actually ready to reduce the block time um so we are actually working on this uh um this release that's going to come uh after the release going to go out next week uh so that in that releas will reduce the block time to 400

20. 9:48

    milliseconds um and that's going to be a great improvement over today which is about like 1.1 second uh and it will bring a huge benefit to the entire ecosystem mean all the application running on near will be much faster um and especially defi application because they often require multiple receipts multiple helps um and that uh The fact will be um very uh very great Improvement um and uh yeah because of that we'll have a subse finality as well uh which

21. 10:20

    is also very nice and all of that's going to happen in April uh but that's obviously not the end of it uh so we're working on this bigger in initiative called the separation of consensus and execution uh so roughly what it means is that um uh today we have uh you know you know you produce a block and then people apply the block and then uh you know the next block getting um produced through consensus and then you apply that one uh

22. 10:45

    so the downside here is that um the no are not constantly running the uh processing transaction sometimes they actually wait uh for a block to be produced so is like waiting there idle uh so that's what we're trying to do in this uh in this big change is that basically we're trying to to separate those uh those two things uh so what will happen is a consensus will Rong to separately they constantly wrong just

23. 11:08

    like all the transactions um and then the blocks were getting produced and then separately the execution try to catch up um and uh from time to time the the Chun producer gets uh s blocks um applied and then they have the new state route and they would actually submit this um State rout uh proposal from from time to time on what the new stay rout may be um yeah this is kind of a overview of

24. 11:34

    like how it works in the Shing setup so the this idea is is actually not new like people have been working on uh the research related to this for a couple years now and there are some blockchains that have already adopted it um but no one has um done this for a shed blockchain uh this primarily because sharding is already very complex and if you layer this on top of Shing it's even more complex um and that's why even even

25. 12:01

    if you just look at this diagram it'll probably be like what am I actually looking at um it is yeah it is quite complex um but luckily we already have the design uh flashed out and uh we're working on the implementation of this so what this means is that um it will give us two things one is that the block will be even faster because we don't actually wait for execution uh so that basically you um they the only

26. 12:26

    thing you do there is just like other transaction package uh package them into blocks uh so it allow us to wrong to have a even faster block production time that's where the 200 millisecond block time go comes from but also higher seput because um the nodes constantly will be constantly executing transactions and receipts um and they're not actually wasting any time waiting for uh

27. 12:50

    consensus to be achieved uh so the serut will be higher as well and this is also one of the ways we will get uh suput improvements uh for single sh okay so yeah uh looking forward uh we we walk uh hopefully by this by the end of this year we'll have extremely fast and scalable chain 200 millisecond block one million transaction per second uh and that would be a perfect uh settlement and financial layer for a agents um however many they may be uh so yeah it's an exciting future to look

28. 13:22

    forward to and um that's it thanks all right all right there we go cool so I'm G be showing a lot of things today and I've got a super long slot so we're gonna hang out for a little bit um all right not

29. 14:23

    that there we go cool all right hey everyone my name is Kendall I uh work on a company called proximity that does a lot of research and development for the near ecosystem just last week we had a very exciting release we are calling shade agents so the tldr right there on the screen these are truly autonomous and we really do mean that noncustodial multi-chain agents so uh agents are very hot right now mainly outside of crypto but even inside of crypto um these are just a few

30. 14:55

    of the many many projects that are launching uh different types of agents um on the web two side of things things things are moving very very quickly uh probably some of the most exciting things you've seen is like the operator from open AI they can actually control your screen uh we have anthropic that has a similar type of product like they've developed an entire standard for how agents can interoperate together uh

31. 15:19

    but for the most part they don't uh complete many actions for you because they really do struggle with authentication payments in particular and really anything that involves confidential information so that's the web two side of things on the web three side of things most of these projects here are super exciting but they I would classify them as like Frameworks in the case of Arc uh Eliza Etc uh we have

32. 15:44

    virtuals up there they're also a very cool project but similar kind of a framework and then a Launchpad and then we have things like uh AI BT which has done an amazing job of of think generating a ton of traction it's like probably dominating mind share more than just about any other entity on uh crypto Twitter but it's it's you know it's mainly it's a it's a Yap bot is how I describe it I think uh frasa in particular that's some with the green hair is probably one of the more

33. 16:10

    interesting experiments they were also kind of just the interacting with the agent trying to talk to it but you could actually try to extract money from it which is kind of like a fun way to turn prompt injection into into a game um so basically the the tldr and the way agents are today they can uh get information really well um they can kind of get you to the point of taking an action but generally they're not very

34. 16:34

    good at actually taking that action and there's a few reasons why um so I mean I think this is a there's a couple of things that uh that you need in order to have a truly autonomous agent I think the most important end result is that they can actually complete any workflow for you end to end which includes payments includes actually going out into the world or the internet or wherever it is and doing something um

35. 16:58

    but uh yeah we're going to Focus this mainly on how we can build autonomous agents in the web 3 space and so these are some of the criteria and how you actually create a an autonomous agent like what you sort of need uh the first one is probably something people don't think a lot about but we actually think it's one of the most critical pieces which is this idea of decentralized Key Management what we mean by this is that agents are going to need some set of

36. 17:20

    keys that they can interact with but those keys actually need to be able to be interact with by multiple instances of the agent and the reason for this is that if you have a key that's too closely embedded into like where an agent is actually running what that means is that if that agent fails for any reason that key is lost and thus any funds or any authentication that was dependent on that key is also lost in crypto in particular this is kind of the

37. 17:45

    most fundamental piece right is that like basically not your keys not your crypto so if you don't actually have a persistent access to the key and authenticated access to the key then everything that was a result of that key which is literally everything you were doing in crypto is lock lost so we actually think that first piece is incredibly critical un fortunately that's something we've been building in near for quite some time now uh with a product we call chain signatures getting into some of these other ideas here so

38. 18:09

    uh we also think it's very important that you know exactly what your agent is supposed to be doing and one of the easiest ways to do this if if you can is you verify the code that's running you and ideally you even verify the models that are going to be used to kind of perform some sort of action um so what we've been doing is working on ways that we can actually provide these guarantees as much as possible um and then getting

39. 18:32

    into some other very important aspects but uh you know kind of I guess forther field is like you do want uptime guarantees uh the uh neari Team launched a really interesting paper called proof of response it's basically designed to solve this problem we've been investing very heavily in this idea of trusted execution environments that are very good at verification but they don't actually guarantee you up time for any reason and that's what proof of response is is designed to solve um and then some

40. 18:57

    other things that I think are going become best practices but are still a bit nent and new is this idea of using smart contracts more as like guard rails for these models in these agents rather than as like the where you actually code the agent itself I think realistically given that agents are require a lot of offchain compute they require a lot of access off chain dat data and State uh you actually want to use Smart contracts more to keep them on track and make sure

41. 19:22

    like hey this agent is proposing to take this action it's proposing to deposit my money into a well I want know that that like a is a good not a good app it's like somewhere that I want my money to be sent to like I I that basically we we think smart contracts can be used uh very creatively to actually keep these agents doing the things they're supposed to be doing and then last but not least most of these agents when they're acting

42. 19:45

    on behalf of a single user they should be kept as private as possible at least the actions that they're taking I mean the second you touch a blockchain that's mitigated a bit but like the decision process that goes into making that uh that action your personal data might be a part of that decision-making process all that should be kept private and so what we did is like sought out to create a system that that can give you those assurances so uh yeah basically what we

43. 20:08

    call them is shade agents um we are convinced that these are currently the first truly autonomous agents because they actually hit each of those points and we'll go through exactly how it works so here you can see a diagram of basically the shade agent stack there's actually two components that matter the most here um so the first and you see this is like in that kind of trusted execution environment Banner is this worker agent this is basically what you

44. 20:33

    think of as like an agent this is what most people are building when they're building an agent usually it uh accesses some or like there's some wakeup condition okay agent's going to run whatever that is like someone requested agent go do this for me then there's uh some access to some data some State maybe that's information about the user maybe that's information about like uh

45. 20:55

    the price of a current cryptocurrency because it's going to decide to make a trade or not uh and then finally there's like some llm or model doesn't have to be an LM could be any sort of model where there's going to be basically like a decision-making process that'll be resolved and then finally once that decision is sort of finalized and the agent's like okay I want to go I want to take this action then that action needs to be sent for execution somewhere so that's the worker agent that's running

46. 21:19

    inside of this trusted execution environment meaning that the actions that are taking inside of this environment are only known within the environment there's no way to exfiltrate or no easy way to exfiltrate the data from here and also means that this code cannot be changed without basically wiping the whole environment and thus we'll talk about in a second why like basically removing any of the information that's in there the second major component is the Smart contract so we're using the smart contract for

47. 21:44

    basically three main things as you can see there the first is to actually register this worker agent what we mean by register is that this smart contract is going to require that this worker agent actually submits basically a proof of the code that it's running this does this using kind of a primitive of the of a trusted execution environment which is called an attestation quote so basically what will happen is that the the the environment itself in this case like

48. 22:08

    let's say an Intel CPU running this this special environment will actually generate a quote that shows the exact current state of this environment so uh in our case the most important thing it's going to be showing is the code hash of what's actually running in there and then all of that is basically it's signed by a key that's embedded within the hardware itself and then that key is basically attested to by Intel in this

49. 22:32

    case who's saying yes that's actually one of our CPUs that we sold we verify that like it should be you the Integrity should be intact and so the smart contract will actually take that quote it'll confirm the signatures from Intel of valid it'll confirm the signature from the hardware itself is valid and then it'll actually extract that code has and check that it matches the code hash that the developers of the smart contract the deployer of the smart

50. 22:55

    contract set as like this is the this is valid worker and what this means is that anyone can actually spin up this worker agent on their own you know their own assuming they have the right device their own device submit this quote to the the smart contract and then all of a sudden they're now a registered instance of a worker agent this important because what this means is that if any of these work agents go offline anybody else can

51. 23:17

    spin up a new one which gives you the resilience that's important for like actual autonomy um and then finally what this smart contract is going to do at least in what we think is the best practice is if uh if you take advantage of the feature we have which is chain signatures which tldr is that a smart contract can sign transactions basically we've given smart contracts Keys via a decentralized multiparty computation Network then the smart what the the

52. 23:43

    worker agent will do is actually request to send a transaction uh on behalf of this whole system the smart contractor will verify that the worker agent is registered verify that the transaction they're requesting is one that makes sense that fits some some rules uh and then they'll actually go out sign the transaction using the smart contract's own key and then finally send that to the network and we'll actually walk

53. 24:06

    through the code that shows how that works in a second um so yeah here's kind of another flow of how the process works so it's like step one deploy the smart contract step two anyone can deploy a worker agent uh and there's a couple of of like helper steps that we've created you have to each worker agent will have a near account because ultimately it's sending near requests to the smart contract on near in order to like send

54. 24:31

    these transactions to the destination chain uh so there's like a funding step then you also check like is this worker agent registered because if it's not you can call the smart contract but you'll get rejected every time so you have to send you have to complete that registration step and then finally you can actually then make request to the smart contract to send transactions and it'll approve these signatures and then actually uh you know complete these actions for you um so how does this

55. 24:54

    different from from currenty implementation so it's become in Vogue I guess to run crypto agents in a trusted execution environment because those are seen as at least at least better security than running it on just like you know some some random Hardware somewhere uh the problem is that for the most part these uh T's they they have a key that's embedded in them and that's good for security because that means that you know someone else doesn't have

56. 25:18

    that private key and they're not misrepresenting that this only the te can basically perform actions using this key uh the problem though is that if anyone is able to pull the plug on this physical Hardware that key is lost forever and that's important that's a really important security feature but it does mean that you can't actually trust that any of the funds you send to this key are always going to be there which is like an insanely it makes zero sense like that's

57. 25:42

    not we don't think that's like viable at all I would not recommend you send your funds to any of these kind of Agents uh and so what we set out to fix with the shade agent is that the worker agents are basically jointly able to use the same set of keys so the keys are persistent they'll always exist uh but the only way you can actually request these keys to sign and do something is if you register and you prove that you're running the right code in the T

58. 26:05

    that's kind of the tldd of this whole system um so here yeah we kind of show like how you can basically deploy one of these worker agents it's actually pretty simple uh if you use a product called follow Cloud they um they provide a really really nice way to deploy these agents so you can basically build your application your worker agent using Docker that'll generate a unique hash um

59. 26:28

    that is basically like the the hash of the code that you're actually running uh and then all you have to do is basically uh create this Docker Docker composed. yaml and and deploy that using follow cloud and your work Regent will be up and running um and then here you can see actually the code of this is running in kind of our example worker agent so what's happening here is we're generating a key within that trusted execution environment that'll only ever

60. 26:54

    exist in this instance um and the the point of that is that if this worker agent goes Offline that key is lost which is an important part of like the security properties of this thing but you can then just spin up a new instance you'll generate a new key that's fine you just have to re-register that's all that means um and then here you can see we're actually uh getting the code hash of this creating this this attestation quote and then calling that register

61. 27:18

    worker function on the smart contract basically proving that within this instance of this worker agent we're actually running the correct code and yeah here so we we we built like a basically a reference smart contract that actually implements some of these methods uh so we've got two basically helper methods one is this uh this owner just basically checking like is there who who's the owner of this smart contract who can update this this

62. 27:43

    code hash in a best practice this should either be immutable you should just not actually have an owner meaning the code hash can't be changed or you know if you want your system to be able to be developed over time this should be either like a dow or I guess like you know worst case like something like a multi-c um and then we also have this kind of you you see that that like method a that's basically uh requiring that the caller of that method which

63. 28:06

    will ultimately result in a transaction is running with a given code hash and so one way you can actually use this is you can have different agents that perform different functions they'll each have different code hashes but then you can have like basically maybe there's like three different types of Agents you want to run in one system they each have different code hashes and you'll have different methods that will pertain to those different workers so one worker

64. 28:30

    might be able to like rebalance funds across lending protocols one worker might be able to uh make trades one worker might be able to update the whole system uh and they can each basically call be be authorized to call different functions on the smart contract um yeah here's kind of just some other another way to sort of view that cool so we're going to go through all that in more detail in uh just a minute here um but

65. 28:54

    let's zoom out a little bit and talk about like what can you build like why is is interesting so four major areas that we've identified and I mean frankly this is probably just the beginning um I think actually one of the most interesting use cases for agents is taking a look at the def apps that exist today recognizing that just about all of them have a critical component of humans in the loop and thinking about like where can you actually remove some of

66. 29:19

    those humans in the loop or what new types of applications could you build if you could have some sort of intelligent decision- making that could happen very rapidly which is like one of the clearest advantages of something like AI versus you know having to like have this kind of slow necessarily solow process of having humans in the loop so it's like that's one really interesting way to think about like imagine you could just replace it down with some agents

67. 29:42

    and will would that enable you to build think another way to think about what you can do here is that because of the fact that we're running a lot of the core logic of this system in something like a trusted execution environment that can itself have sort of verified access to the internet meaning you can call offchain data providers um and I mean at least know that the uh that that it's going to consistently call that route you still have to trust that that you know that that like URL is

68. 30:07

    going to serve the right data but um but basically this enables you to more flexibly utilize offchain data uh without having to like get an oracle spun up for specifically that purpose and think about and then and then think about if you can add them as offchain data but then also utilize any type of model in order to make decisions so we have a couple of of examples ideas there uh we think like you know a very basic one is just a

69. 30:31

    lending Optimizer right where you can delegate effectively your funds to this agent uh it'll then look for the best rates on a set of lending markets and it'll rebalance your money across these over time is a notices that things are changing there um and then last but not least I think like you can actually create interesting markets for basically anything that's digital we've seen some expands already where people are like letting you pay for a single use of an

70. 30:56

    API key so I mean a basically could be open AI itself right like you want to send a request like a prompt to open a open ai's API and then get back some sort of response you can actually create a protocol where you can basically delegate anyone could delegate a single call and then have you pay them for that single call uh which could get really interesting another area that we find pretty fun and I'll actually zoom out

71. 31:19

    and show you exactly how this works today is this idea of a headless UI so because these agents can be tracking interaction basically anywhere and then respond in a verified way you can actually remove the idea of creating a new UI and like let people for instance uh interact with the application entirely through something like Twitter um so let's actually show how this can work because we built an example all right so uh we'll built this agent called shade agent 007 basically

72. 31:52

    what it does is it listens to any sort of request for its name it then analyzes the body of tweet and determines is this thr shared is this like a negative tweet is this saying something positive uh and then it determines which token it's going to send to the user and so right now we have the user including their account in there but you can actually even even get rid of that um so I'm gonna send this tweet I'm actually not

73. 32:15

    sure whether it's going to uh frame this as H base or shade but uh let's find out and it takes about a moment to respond uh but yeah so basically the idea here is that um you can have any sort of existing interface where users are able to interact either directly with these agents or even just make any sort of comment um these agents can then see okay cool there was a request that was

74. 32:46

    basically effectively came to be where like this user is trying to is trying to do something and then it can perform an action on their behalf uh so you could even have like an entire wallet that's built into x.com where you just could say like send X tokens to this address and then the agent would be able to respond and actually take that action and actually do something um let see if

75. 33:10

    it's responded yet all right taking a little bit longer so we'll come back to that one um and then last but not least is this idea of web markets um and so for this one we actually worked with uh with uh the Uma team to come up with a uh a very basic demo one I think is pretty interesting that can um basically uh create user generated Market maret uh and these markets can be agent settled they could be agent resolved they could be agent traded uh and they can access any sort of public API or private uh or

76. 34:08

    private web data uh so we think this opens up like a lot of opportunities to uh basically trade based on digital information and um digital like yeah basically digital information right let's check back in on our bot and see if we've gotten a response yet there we go cool so it actually sent me these B tokens and this is going to be on hyper liquid so let me um yeah we'll come back

77. 34:34

    to that one during the workshop basic I'll show you guys that I actually received those tokens on the hyper liquid Bain net so basically what it did is this agent looked at this tweet determined that this was a positive tweet I guess it's harping more on the age of AI execution uh than on my comment about AI swap uh and then it basically decided to send me these tokens to this address on hyper liquid uh which is pretty cool so I welcome anybody to out if you tweet at shade

78. 34:59

    agent007 includes your address there there and then say whatever whatever you kind of want and uh it should respond to you and actually send you some some real tokens they're technically sold down tokens they cannot be transferred um but it's still pretty fun you will be able to see them in your metamask wallet um all right so now we can actually just go ahead and hop into uh a specific example so um we will be walking through this

79. 35:24

    template but and if you want to follow along I recommend you go to near ai. a shade and then you can actually just scroll down just a little bit and you can see uh the template itself and then we'll go ahead and walk through this code but first I'm going to show you guys uh what we built uh that uses the Uma optimistic Oracle um so what's cool here is like you can actually see this you like this this uh this entire UI is being served from within this trusted execution environment generally that's a

80. 35:56

    bad idea because like you basically want to minimize any sort of access to this environment that you can ideally you have this environment only calling into the smart contract and that's one way rather than two-way otherwise you do open up some attack vectors but for the purposes of this we figured we'd make it a bit simpler and actually have a UI that's still being Ser from here so what we're going to do here is we're actually going to take some of the resolution

81. 36:18

    criteria from a recently settled Market on poly market so we'll take this one this is from uh what is this here it's the most passing yards on championships Sunday so this was all about a month ago um but never too late to kind of check out what's happening so we'll go ahead and post this in here and then I'm going to click submit and then so we can see what's happening I'm going to pull up

82. 36:39

    the logs here um let me check this in let do this cool so you can see here uh it's like checking a couple things like my balance checking the key making sure that I'm actually authenticated to call this method then here you can see it's actually this is the inut of okay this is the the market that we're aiming to resolve and then you can see uh here it's basically has now like authorized that I can call this transaction uh that I'm I'm able to actually send this this signature it's generated the signature

83. 37:12

    here this is going to be the address on uh ethereum aoia that it's sending to and then bam it looks like we're we're sent so what we can actually check this is on the um umaa test net page itself to see like did this actually send and let's see it looks like this is ours right here yeah this is our uh Market will resolve according to whoever had the most passing yards so we've actually now basically from from here yeah we think we have a success so from here we

84. 37:43

    basically said okay this is the market that we're looking to resolve we entered that in what happened then is that we'll actually walk through this here so do so this question came in here well this is like us kind of making sure that we know which address to call uh so basically this question came in this is this question string and we passed it to perplexity basically asked perplexity like who had the most passing yards on Championship Sunday perplexity then

85. 38:18

    searched the internet used its RS basically took probably I guess they like Google data plus their L and determine who have the most passing yards and then we actually went and we like Degen like this in this is all in the worker agent we generated this uh request to actually send to the contract saying like hey we determined we want to take this action we're going to prove we're a verified agent where we have the right to basically call this smart contract so here you can see us actually

86. 38:42

    constructing the transaction um and yeah so we're going to call this assert truth with defaults on the Uma actual Uma contract we're going to do this on spolia um and then here we actually put the transaction together so we've got the address the chain ID uh the actual like transaction call itself we generate this unsigned transaction request and then this is where we actually call the near contract

87. 39:06

    is with this like complete ethereum transaction so what we're actually going to do is we're going to send this transaction request this unsigned transaction to the near smart contract um we can actually look at the near smart contract here so we have this get signature function that's going to be being called with this uh this payload which is that unsigned transaction and then it's going to like basically call

88. 39:28

    the change signatures contract which will then then give us the signature back and then once we have that signature back we can con reconstruct the transaction like complete the transaction and then send it to the sepolia network so we basically completed this Loop of like worker agent that's going to be responding to these requests that's running in this trusted execution environment it registers with the near smart contract says I'm running

89. 39:53

    this code hash like this is like this is verified code this is only running with this in this uh in this trust execution environment the nearest Smart contract will list that agent so that that agent can then send arbitrary transaction requests and then what we just did is we sent that arbitrary transaction request of actually calling out to the Uma contract um so that's basically the flow of what actually happens so now let's

90. 40:18

    dive a little bit deeper into the structure of this repo so that you guys can kind of do this yourself um so as we said before there's those two main components there's that worker agent in that smart contract we'll look at the Smart contract first because it's like a bit simpler um so basically in this contract we've got just a couple of files here so primarily we've got this like this live file um so you can see here we have an owner ID we'll have

91. 40:43

    these approved code hashes and this is what initially the owner ID can basically add to and again I in best practice this is either immutable or managed by something like a dow and then we'll have these worker agents these like registered worker agents they can be registered by ID and they'll also have like a mapping to a code hash um and you see here yeah we'll just initialize it and then like the most important functions even more than their

92. 41:05

    require owner is this require worker so this require worker function basically what this is going to do is this is going to tag a specific function as can only be called by a registered worker agent uh and so what it's going to do is like check the account ID of anyone who calls this and then determine like are they basically in the approved list and then like look at their code has and say okay this worker agent is running this code has does this match one of the

93. 41:27

    whitelisted code hashes um and then here you can actually see the registration step itself so this is what the worker agent will call when it's first getting set up and uh you can see here like we're actually picking a piece aart the collateral they sent this is basically that attestation quote from The Trusted execution environment and then we're going to actually call out to this collateral contract and run this verified check which is basically

94. 41:51

    looking at all the signatures and making sure that they're valid from both the hardware uh the hardware itself and and from in this case Intel since we're using Intel TDX so that's the contract so basically like for the most part you guys can Fork this contract uh use it as is the only thing you have to do is add additional methods here like I I showed before on this um on this umabot is we

95. 42:13

    had that kind of like like basically the the one to get the ecdsa signature that's all you have to add and then you're pretty much off and running and then we can look at basically this worker agent which is effectively the rest of the codebase so we set it up as like a nextjs app to make it really easy to handle this registration step because like it is a bit involved you have to generate this quote you have to generate a key and you have to actually call the

96. 42:37

    near contract and you like fund your account first it's possible to do all of this through the CLI but we just wanted to make it simple so we put together this next JS app um so you you don't actually have to change too much I'd say like you can mostly keep that part out of the box what I recommend changing is if we go to uh the pages here you're going to want to add rout to this API folder as basically right now it's just set up this is just basically the registration logic so it's not actually

97. 43:02

    doing anything but uh if you add say like another call here that does actually does something interesting and you add basically a file to this uh this API folder then you can actually like perform an action and so if we go look at my Uma example here then I can show you the action that I added so we'll go ahead and open up my code here so you see uh here like I added this Uma file here I also added to this index I added this uh handle

98. 43:34

    question submit that's basically that form field that I was using and you can see that what happens when someone enters some data into that for field is I call this Uma API routes and so here is where we're actually doing the kind of interesting stuff so this main function here this is what's called when you call that UMO route so the first thing we're going to do right we're going to generate that um the address and so what we're doing here is we're

99. 43:57

    actually determining what address we want to call from on the evm side and so this is basically like the way chin signatures works is each smart contract basically has a determining address it can request uh transactions to be signed for and so the inputs to that there's basically a master public key of the MPC Network itself we have that in the docs it's super simple to get um there'll be the actual account ID that you're

100. 44:22

     calling from so this is basically your account ID of your near smart contract a path which is just an arbitrary string the reason for this path is that you can basically control any number of addresses on a destination chain and then finally like the chain itself like what type of chain in this case it's an evm chain so we're gonna that here but uh you can also do this for Bitcoin very soon you'll be able to this for salana and basically every other chain um and

101. 44:46

     then yeah we basically you know take the question string that was being asked and and do what we were talking about before calling perplexity uh getting the result from perplexity constructing a transaction and then actually sending that transaction first to be signed like verified and signed from the new SP contract and then finally to actually be relayed to ethereum and so the important thing to remember here is that you can actually do this for basically any chain

102. 45:10

     right now every any ecdsa chain any chain that supports ecdsa signatures uh within the next few weeks you'll be able to do this for any chain that supports EDSA signatures which at that point means you can pretty much call any chain um so yeah that's that's that's that's pretty much the uh the structure of this project so um yeah we'll probably have a little bit of time for questions um but

103. 45:33

     I just want to make sure you guys have this link so again just the uh this is the link to go to to basically get the docs of how to build a shade agent and then get redirected to that repository so that's going to be this near. shade route and uh yeah that's pretty much it I know I've been yapping for quite some time now so yeah if there's any questions happy to happy to to dive into those so we got at least like 10 or so minutes

104. 46:10

     left sure thing man we got another one right here thank you all right um let's say you wake up tomorrow and then all of a sudden there's thousand shared agents and they're all doing some really cool stuff that you want to see what is that stuff that you want to see if you can Le like the top three yeah I mean I think the laow for it is going to be uh managing assets on behalf of users and existing defi applications so we'd love to see kind of

105. 46:44

     like a lending rebalancing one I think there's quite a few agents that are starting to do that now most of them are not verified or are running just from of users local machine I think that's a bit dangerous so I think you can even take some of the existing ones and just make them in the shade agent that would be interesting but even better is that one of the unique things you can do here is you can build multi-chain rebalancer since we already support from a single contract signing transactions for any

106. 47:08

     chain so I would basically take one of those lending rebalancer and rebalance between say ethereum arbitrum and base to start and then once we launch EDSA you can add salana s you know whatever whatever other change you want so that would be one agent um I think we're really excited to see these kind of head this UI Concepts so what an idea that was thrown out and this is not legal

107. 47:31

     advice because it is definitely a little a little but you can create kind of like a betting agent sort of like a Twitter bet Esco agent I mean I'm sure everybody's if you spent any time on crypto Twitter you've seen you know somebody challenging somebody else to like bet on the price of uh Bitcoin in three months and then they have to recruit Kobe to act as the esrl which isn't really good for anyone well with this you can pretty easily as long as

108. 47:56

     you have clear resolution criteria you can actually just create a bet es give each of these users an address to send to they could send the the the funds there and then once the uh once the date passes like the the the end result the BET passes then the BET will just automatically resolve and send the money to whoever the winner is and these users don't have to do anything and like all we have to do is interact with Twitter and then send funds to these to these

109. 48:20

     addresses they don't have to interact with any UI so this is just a basic concept but it can be extended to anything and then last but not least I think this is actually like I have a specific idea here but there is a way to build kind of a true zero person company where like you can actually have just these agents that sort of act on their own behalf and either funneling funds into a dow or or even just to themselves

110. 48:44

     and I think what this does add is this layer of trustless where I mean I hav't even thought of what the business ideas are but there's definitely an opportunity to think about like where is trust absolutely imperative where do we not even really want humans in the loop we just want code and then go out and build that system I think this is like really one of the first times you can actually do that in a much broader way like smart contracts gave us a bit of that but we only have a small number of

111. 49:09

     truly trust minimized smart contracts it's basically unop and that's like kind of one of the only ones there's been a couple of other experiments but they're pretty light so I think this like really opens up the design Bas for those types of applications all right thank you anyone else all right thanks everyone so all right uh ladies and gentlemen there is plenty of uh coffee to go around for everybody over there there's some uh scram there's food there's cheese uh I think that they might be

112. 49:57

     putting something a little bit different on pretty soon as well there's iced tea there's lemonade there's water if you want to stay extra healthy there are cloths and swag and pins and jumpers Etc out there so please go and get them because we need to give them away uh we will be back here at 10 2 that is 210 for the Americans uh so keep an eye on the clock uh where we will have some

113. 50:19

     Heavy Hitters including the co-founder the ukin so catch you then hold on one

114. 53:26

     oh

115. 54:57

     n oh d

116. 56:26

     d he now

117. 58:25

     B d

118. 59:26

     ah a oh

119. 1:00:56

     m w

120. 1:02:56

     oh

121. 1:05:08

     n

122. 1:06:24

     oh

123. 1:09:54

     n it's

124. 1:11:54

     sh sh the

125. 1:13:20

     all right okay here we go um one two three four five six witness ray1 trillion.com all right ladies and gentlemen I know that the food is delicious and the coffee is even sweeter uh but we are about to uh welcome our very next guest our next speaker did that did that rhyme I think it did uh if not um I will let you enjoy the wonderful Alex shenko to talk about all things near intent so please do give

126. 1:13:50

     him a big round of applause okay okay hello everyone my name is Alex shenko I'm the CEO of Department of near efficiency um I'm the guy who is together with Bowen making sure that near protocol is working and we're going to talk today about neur intense maybe some of you have been already hearing about this protocol and actually using it raise your hands if you did okay that's great so lots of people who already tried it and um um as always I would like to start with

127. 1:14:28

     U some kind of citation from a great person uh that I really admire and um today this is the one uh there are two Infinities in the world the size of the universe and the number of agents that will be launched and I'm not 100% sure about the universe this is this is what Einstein said approximately 100 years ago and um that's actually I think this is actually the truth and um like many people like there were already couple of talks uh mentioned in Ai and and agents

128. 1:15:00

     and I would like to start with you know a basic and a basis here so what is an AI agent right so this is a system that is able to perceive the environment it is able to process this information then it is able to take actions towards some specific goals that are set and then it is able also to learn within this process right so it's going to this is something that we probably you know understand already now um it is very easy to Envision uh a future when these

129. 1:15:34

     AI agents the systems that are trying to achieve their goals uh they have different goals right so some of the systems are helping you to get food deliveries other systems are helping you with the transportation um some other systems are helping you to swap tokens and because of this it is very easy to see the future where we are not going to have just a single AI agent that is going to help us out but rather we're going to have a multitude of them right trillions right and uh that's actually the case and if so then they

130. 1:16:07

     are going to have their own specialization they are going to uh be experts in some domains and uh in order to uh to provide good services to the users who are going to use this agents they probably would would need to have a place to cooperate if my AI agent knows everything about myself then maybe it is not very specialized in the food delivery um that I like and then maybe it needs to cooperate with other AI agent who is specialized in this so the cooperation between the agencies is very

131. 1:16:47

     very important thing they need to discover each other they need to negotiate in between themselves to figure out the deal who is going to pay whom or how it is going to be structured they need to settle this deal and in case there are some problems with the delivery of the services they also need to raise dispute cases and these disputes need to be resolved right this is um this is like a thing that that actually need to exist

132. 1:17:16

     and uh the truth is is we are building it right and this is a near intense and this is a grand Vision behind near intents so this is a protocol that contains an offchain message bus for communication and discovery of the eii agents this is a new type of action on the near protocol that is specifically existing in order to settle these negotiated parameters of the deals in between the AI agents and then there is a payment uh Channel standards that is

133. 1:17:50

     connected to it there is also a dispute resolution mechanism that is built in this thing so everything that I'm talking about up until this point is pretty generic and pretty forward looking right just because AI agents they are making their baby steps right now and in order for such a system to mature it is going to take years um but what we can do right now well we actually can do a multi-chain

134. 1:18:20

     DEX right now and this multi-chain Dex is something that g gives you a first very simple typee of an intent uh that people want to do and also this is a use case that works in crypto right now right but if you would think of it um it is not very far from the general protocol that I was talking about couple of slides ago people in order to trade multichain they need to discover a counterparty

135. 1:18:54

     with which they need to trade they need to negotiate about the price of the asset and they need to settle it somehow so the actual exchange of the tokens need to happen the only thing that is not existent on the multichain deex is the dispute resolution mechanism because the amounts of the tokens are tracked on the blockchain so the smart contract can be a dispute resolution point that there will be no disputes because the smart cont contract is able to check uh the

136. 1:19:26

     amounts that have been traded right so in fact multichain Dex though it sounds very different from the AI protocol um or AI agents protocol um it is actually not very far from that and that's why this use case is a great first use case for The Wider um Vision that we see for the future and it is live you are able to try it out on near dash.org it is in a better stage at the moment so please be careful with you know your money and

137. 1:19:59

     stuff like that um make sure that you are not uh not you know you're able to deposit there the things that you're able to lose now what we have right now with near intense in comparison to what we have been talking about uh on redacted conference uh just uh when three months ago we do have lots of chains that I already integrated with the protocol we are adding These Chains rapidly so we

138. 1:20:29

     now have Bitcoin salana ethereum near base arbitrum Ripple Dodge zcash Bara all of the Aurora virtual chains that are launched right now they are all integrated with near intent which are more than 70 virtual chains that are available and more chains are coming soon the list of the integration we are slowly starting to run out out of chains for integration just because almost all of them are integrated right um uh near salana and ethereum

139. 1:21:06

     wallets are supported so you are able to log in with any of these wallets inside of the front end of the intents and you able to execute transactions with this protocol which is also pretty great you don't need to have an year account in order to transact on intents multiple partners have already integrated the protocol directly into their front ends because it is an open protocol anyone is able to do you don't

140. 1:21:32

     need to go directly to near- in.org in order to use the protocol that's that's good and even more Integrations are coming uh we have a natural more than half a million daily volume and it is steady grow we have seen the volume of swapping uh exceed in several million US Dollars uh daily trading volume uh already on this protocol uh but uh like every single day there is more than 500k um in comp person and this is like in three months right so three months ago there was zero and now we have not

141. 1:22:05

     been running any you know marketing campaigns around it we were not dropping people tokens anything people just started to use it because they see the value when they're able to permissionless trustless uh transact across chains and we have more than 50 tokens that are listed there but all of the major tokens that usually people are trading on centralized exchanges I'm talking about stable coins uh base tokens of the corresponding chains all of these tokens are there available and

142. 1:22:38

     uh the thing that I I I can tell you is that uh already right now you can drop using your centralized exchange and instead of It Go and use near intents now obviously obviously ly I would not be me if I would not bring something new here to share with you and uh I'm glad that I am able to do this and all of this happening because of my tremendous team uh that is just building all the time and there are couple of things here and the first one is the support of

143. 1:23:16

     pasis now you're able to log in in near intense in the protocol and in the front end directly with a pass key you even don't need to have a crypto wallet anymore in order to non-custodial store crypto that is located on different chains you're it is live right now you're able to go there log in with the pass key and here you go you have your crypto there and you're able to swap it and do whatever you want to do

144. 1:23:47

     there is no not a single transaction that a user is sending the only thing that user is doing is signing the message and it is able to do with the pass key cryptography which is different from the ne cryptography that is used but it is working like that so that's the first thing yeah and the best thing I encourage everyone to try it out because what it gives to you also is the wallet lless experience where there is no switch of the interface from the dab to

145. 1:24:18

     the wallet in order to sign something you are completely staying in the dep and it makes things so much simpler and that the flow is just straightforward so encourage everyone to to try it out and there's a second feature which is the OTC trades you can think of it as a peer-to-peer trading where instead of trading with the market makers that are providing liquidity inside of the protocol you can trade with your buddy you can create a trade in which you specify the amount of

146. 1:24:49

     tokens that you're selling and the amount of tokens that you're getting back and you can send it as a link to your friend or to the counterparty with which you willing to trade and then this counterparty is able to click it and it is able and this person is able to counter sign the trade and then it is going to be settled so there is a true peer-to-peer trading why this is important um for

147. 1:25:14

     people who are caring about with whom they are trading like institutions um they now able to trade only with select Ed Partners um because they have passed kyc or KYB or something like this so all of these available in the um in the near- in.org right now and together on top of this feature um um in the following days we are going to release a functionality of Link drops and this is functionality that is uh that is even better um or like this is an additional step this is a kind of a a

148. 1:25:54

     sub use case behind the OTC um where you are able to put inside of a link drop um uh you can you can say that I would like to transfer 10 usdc to the person who is going to redeem this link drop and then you can send this link to your mom and she is able to click it log in with the pass key get 10 usdc swap five of it into Bitcoin swap two of it into Z cash keep the rest of it for for herself

149. 1:26:28

     and then obviously sell everything into Aurora and hold it forever um but that's actually the thing that you're able to do she doesn't need to install a crypto wallet it is going to work like that it is going to work like magic with her face or her finger signing all of the requests from my personal opinion as a person who was always pushing towards the better user experience this is the way how

150. 1:27:02

     things should work because this is how web2 is working right now I'm getting my revolute account or my bank account I'm just looking at my phone I'm sending money to somebody else and then they are receiving this money this is natural it is not natural when I need to switch to some kind of wallets and do some complicated things right so so this is how things can work in crypto and the most important thing I I would like to

151. 1:27:33

     put an emphasis here uh this part is like this front end it is an open- Source frontend it is just a reference implementation for the front end uh what we would like to see is different protocols different distribution channels different wallets to incorporate this solution there directly inside of their front ends so that their users are going to see absolutely the same user experience while they don't need to switch into other you know

152. 1:28:04

     applications into their browser in order to perform such a straightforward and simple action as just swapping tokens so I I encourage everyone to do this especially if you have a distribution channel uh we do have lots of partners that are in the process of integration of the near and tense and uh all of them are loving it so in the following months you're going to see quite a number of big announcements around these things so my mom uses near intense with

153. 1:28:36

     pasis so why aren't you thank you and besides the talk we actually have the U an additional uh kind of live coding or like a demo thing I'm not going to do the coding but I'm going to show you one interesting thing how AI agents are able and are actually working today with near intense and I would like to give a big big shout out here to Vadim from neari who has been actually building this um DCI agent that I'm going to show you um

154. 1:29:19

     and uh he's the The Mastermind behind it um I'm just to kind of stealing a little bit of his Fame and showing this to all of you but credit everything to him so what I'm going to show you is an AI agent I'm going I'm going to make it super large an AI agent that is available right now at um app. near. you can go there there is a section around the agents and the uh agent is called D defi how how do you read this I still

155. 1:29:57

     didn't figure out how to read this but let's call it D and U this agent what it is able to do I'm not sure whether there is an there the description is you know as you can see as as usual in the alpha projects this is an alpha version of it but this is an agent who is able to accept your money in the form of usdc on the near blockchain it is able to analyze the crypto Trends based on the price data from the coin gecko it is able to make a decision in

156. 1:30:37

     which tokens to invest and it does this investment through the near intense it holds this portfolio of tokens for certain amount of time and then at one day for example it liquidates this position and sends you back this money literally what this a agent is it is a tool for anyone to invest in crypto without a knowledge of anything of of crypto it's like um it's like if you're if you're a type of person who is buying you know lottery tickets or something like that you can you can do

157. 1:31:20

     it like that probably there will be at some point in time several different different profiles how you can invest invest more into riskier assets invest more into more stable assets right and stuff like that but this is something that you can do already right now this a agent um has obviously quite a lot of source files but let's let's check it um so there is a by the way all of this is just written in Python so it can work as an ordinary python code uh I

158. 1:31:54

     know that the most hyped part about near is tees so you can put this AI agent inside of the trusted execution environment so that it becomes a non-custodial or like a shade agent that Kendall was uh launching just last week so this can work as a shade agent and um it has the uh the part for the analysis of the trend so as you can see here there is a crypto list of some particular tokens that are listed on the neur in tense and this agent is trading these tokens um uh and uh what you're

159. 1:32:33

     able to do is to actually update the trends and this logic is working through um uh through getting the information from the coin gecko API so this is a this is a function that is called get investment recommendation and uh but like inside of it it's it's a little bit down there but there is a fetch real time data so actually this agent is fetching data from the coin geeko right you can again you can open it it's it's fully open source and fully available

160. 1:33:04

     now uh once it gets the information and by the way this agent is running this evaluation on its own um once per hour or something like this then what it has is the part that actually interacting with intent right so this is a code that theim needed to write in order to make sure that this program this bot is able to execute respective transactions within the near intent protocol and if you're are going to go into this stuff you're going to see some

161. 1:33:42

     things that are very specific to the near intents right so this is the RPC uh this is the end point where you're able to get the uh prices of the tokens there is an information about um you know some specific messages how the intense protocol is working then these messages are getting signed uh you're able to yeah this is the thing that that is actually happening you're just this is a function that creates a message that should be signed you know and like there

162. 1:34:15

     is a generation of nonsense there are some different functions that are able to encode and decode data like all of the typical things that you expect effect out of the code that is working with the normal blockchain at the moment right so for example this is how uh how the payload is is created right for for the for the intents yeah serialization data you know all of this stuff there is

163. 1:34:42

     a separate function for withdrawing of the intents right so and um yeah like all of the all of the typical things and uh the last thing that I would like to show uh to you uh probably probably nothing I don't want to show you anything in the code you can you can check it out but I've tried it yesterday I've tried it yesterday and uh um at the moment I back then I tried it um uh from the console from the terminal I'm going to show you the the actual transactions that were happening we're going to see it on near

164. 1:35:17

     blockchain but the intention for this agent is to be able to in to be invoked directly from Twitter and actually today Vadim was showing how he was invoking an investment out of crypto by just mentioning G near AI which is the AI bot um that is that is existing in the in the near protocol so so check out his uh his Twitter account it is Zak Cil z a o d i l and uh um and he and his latest tweet there or one of the latest tweets there so he was actually invoking this AI agent there

165. 1:35:57

     but for the sake of uh just demonstrating you how things have have been happening so this is actually my terminal this is what I this is I hope you see at least a little bit I can make it a little bit bigger so um this is actually the the call that I was I was executing and as you can see there was a transaction with which is a transfer of the usdc token this this strange token on near is usdc so I was transferring 10

166. 1:36:34

     usdc probably probably this was just one usdc 1 2 3 four five yeah this was just one usdc there was a second transaction to invoke it with 10 usdc yeah this is it so this transaction I was transferring 10 usdc to this agent to this smart contract this is not an agent this is a smart contract D.G near ai.

167. 1:36:59

     near and I was together with this transfer I was adding a message that I am depositing on behalf of a Twitter ID which is mine Twitter ID and this is exactly how things are going to work with the integration with Twitter right so I have been depositing this trans have been depositing and then this transaction was executed you can see here that uh this is a transaction there is like a key whatever the things and inside of the logs you able to see that

168. 1:37:36

     um uh that here um was emitted an event that actually started to run the agent and so what happened in this transaction is that this smart contract accepted my deposit and this you can think of this smart contract as a Walt where uh the money of all of the users who are using this AI agent are held because AI agent has a kind of hot key and in case it is broken right uh then you can you can withdraw the money from the agent itself so it's much better to have a smart

169. 1:38:14

     contract where you are storing the data and storing the money they are parked there uh instead of of of an agent that has a hotkey so I was depositing money inside of this smart contract and this smart contract was transferring this money into the AI agent so for that AI agent is able to use intense protocol in order to purchase the position for me so uh we are able to to find this

170. 1:38:44

     transaction this is actually this transaction on near blocks and uh as you can see I was transferring sorry I was transferring I was transferring uh this uh 10 usdc into into diii right and uh if we're going to see the if you're going to look at the execution uh at execution um yeah actually these are the logs that were that that were invoked there um what this agent did uh afterwards it was uh pushing several

171. 1:39:35

     transactions onto near intent in order to take this 10 usdc deposit inside of the near intense protocol and purchase tokens this particular transaction unfortunately was not including any split of the tokens in between different assets because yes yesterday the market was going down all of the assets were uh performing worse than Bitcoin so that my AI agent decided that the most wise thing to do would be to invest in Bitcoin only but this was what the AI

172. 1:40:09

     agent figured out only from the data from the coin market cap or sorry from the coin gecko right and actually what I was able to do is check my Capital position right right so the agent was and going to creating a position for me and this position uh as you can see here was that it was 106 Sates because the token was only Bitcoin so the agent in the end purch decided to purchase only Bitcoin for me and returned this these sets back into the uh this smart contract as I was

173. 1:40:48

     describing earlier and hopefully today I'm going to receive my coin back it is going to automatically it was set for just a single day it is going to automatically sell this satous back into usdc and automatically return it to my account and this is how you're able to do how you're able to in make or create interactions in between the AI agents and neur intense protocol right here right now so the actual Vision that I

174. 1:41:20

     was sharing with you making sure that the I agents are able to communicate they're able to interact with some kind of additional services and are able to find counterparties to execute particular things and in this case they were market makers who were providing liquidity and creating markets inside of the neur and T that was a counterparty for this AI agent now this thing is actually fully working right now maybe

175. 1:41:44

     within a a little bit limited use case at the moment but we are on the road to build and incorporate much more use cases in the future follow wiim for additional updates on on this stuff I think it is super cool already today we are able to invoke it um from Twitter and um I didn't test it yet but I'm going to try it out and if you are willing to build your own AI agent uh go check uh the near. and figure out all of

176. 1:42:16

     the stack that is available there there are lots of things that are available there and you can build use cases like this right away just writing some python code so thanks everyone take questions Alex questions questions I have a question Alex I have a question um when can we expect more liquidity on intense um so probably not everyone have these massive backs as David have has so

177. 1:43:04

     at the moment uh on year intense you're able to swap1 million US dollars of Bitcoin in 1 million US dollars worth of near salana or Stables uh unfortunately we cannot serve um David but uh but for everybody for all of the normies who are swapping kind of with within this amount you are already able to do it good great St thank you uh questions from anyone else all right thank you Alex okay thanks

178. 1:43:40

     you as always as always one of my favorite in the whole Wild World um look give us like five 10 minutes max uh we're going to get the boss miked up and then he's going to come here he's going to do a live whiteboard session he's going to school us about all things AI agents so it is Ilia pauken open next sit tight

179. 1:44:52

     to for to

180. 1:46:22

     to morning h

181. 1:47:51

     l e 4

182. 1:49:19

     my yeah e

183. 1:50:52

     this e okay

184. 1:52:02

     right now either right because I'm running everything correct yeah we I guess we could plan for so all n

185. 1:53:09

     1 two 3 one two three thank you thank you uh ladies and gentlemen um our last Talk of the day for one trillion agents before we uh take some time to relax we open up a happy hour you can get as drunk as you want but don't forget you need to be here tomorrow as well uh the co-founder of Nia protocol IL aukin is about to join us on stage for a solo talk talking about the future of agentic

186. 1:53:35

     Commerce before and you're very lucky that you get to experience this he dives into a live whiteboard session so please for one last time today put your hands together for IL aukin okay well I hope uh everyone who made it here have had a great time with Denver and uh you know keeping it at ,600 meters high but not too high cool so I want to talk about future of agenda Commerce kind of introduce the idea and give you some of the demos as an update from what we presented at

187. 1:54:18

     redacted so one of the kind of you know main stories that I've been talking about probably for past year and a half is that AI is this final platform shift right we're transitioning from what effectively became our Norm right with mobile apps and applications and websites to really this new plane where AI becomes your interface to internet to services and goods to really each other

188. 1:54:47

     right like that's the change and uh just as a side note movie was set in 2025 so we're kind of living it now and the important part here is that as this is happening more and more of you who you are are going to be facilitated by that AI right and right now the AIS are provided by you know different companies and those companies always will have kind of their own profit their own value

189. 1:55:19

     kind of first and so the idea that that we introduced over a year ago have been user owned AI is really how do we bring AI in such a way that it is on your side it's not really uh trying to maximize revenue and profit for some company but actually maximizes your individual well-being and your individual economic success right this really builds up on kind of user own internet you know maintaining full ownership of your data assets and Power of Choice that we've been always talking about this near but also adding this

190. 1:55:53

     idea that AI will be your Universal interface and through that interface it needs to really be the facilitator and also you know firewall in many ways of how you interactive as internet right how you interactive as Computing and Global Market and this needs to be built in such a way that everybody can benefit from right uh economically you know the developers who build this the services who participate in this uh ecosystem and the users right if they're willing to share their data and uh kind of want to

191. 1:56:23

     receive something in return so that's kind of user on AI we've been kind of introducing different parts of the stack it's not you know as simple like cool it's done it's really required a ton of work from the whole ecosystem now one of the concepts we introduced at redacted have been this idea of an assistant right something that you know you traditionally associate maybe with chat GPT but the thing is like chat GPT doesn't really do things for you right it usually responds

192. 1:56:54

     it gives information uh they added like few different features but it's mostly just an informational uh kind of plane but we envision this assistant to be really able to act on your behalf in web two and web three right it has all the context about you and be and being able to you know kind of sometimes and pick actions directly sometimes surface it to you depending on um kind of uh complexity but also it's able to now

193. 1:57:24

     make decisions and you know scour the Earth and internet to find the right choice right option for you right so meaning it will connect directly to other AI systems to other agents uh that are you know representing services and that are representing um other people so one of the points that you know if you've been here a year ago uh I've been talking about chain abstraction right for crypto that's probably one of the main pain points like there's a ton of chains more chains launched over the

194. 1:57:57

     past year there's a ton of kind of different applications now everywhere and becoming harder and harder to use all of this and so chain abstraction we've been kind of introducing this idea uh since the end of 23 to really allow everyone to use in a straightforward way all of this applications and all of this chains and you know there's a ton of teams in the near ecosystem have done tremendous progress I mean hod was just

195. 1:58:21

     talking with speeder uh is showing you know more and more exciting things there but the kind of Next Step Beyond that right is going to be AI as a final chain obstruction it's going to be effectively on your behalf executing different actions across different chains across different applications and you will not even know uh sometimes like the details of that because it doesn't really matter right that's kind of you know you you come to the stocks uh to learn what is going to happen in a year right so this is kind

196. 1:58:52

     of the idea this is where the whole Space is going to be going so just to give you like a visual example right your assistant effectively on the background will be you know doing different actions right I was uh you know planning to come here so it you know we'll be finding what is the best uh like uh when to buy the tickets for me for the travel um on the background it's will you know oh I I like metal

197. 1:59:19

     concerts so uh finding the metal concert soon as it opens up buy the ticket for it and uh you know rebalance my uh uh stable coin in different uh in different borrowing markets based on different apis as they changing right again you don't need to go and manually change this you don't even need to do it through wallet where it's now easier to kind of chain obstruction but actually it will just do it on your on behalf

198. 1:59:43

     because it knows that's the action you would take if it was yourself so that's kind of the idea kind of where we're going right it's a number of AG effec on the back end working on your behalf uh executing different actions and your assistant coordinating this and really you know surfacing all of this and augmenting it with your context so what do we need to do to actually enable this future right uh

199. 2:00:08

     well if you've seen any of my presentations there's always a stack so uh this is the stack to enable that uh first and foremost we need to make sure that all of this is confidential and secure right effectively right now when you're using any of the AI models right you're giving all your data to some company um which you know may or may not handle it very carefully uh there have

200. 2:00:33

     been you know leaks and you know people have accessed other people's data uh and different AI assistants and importantly you know as you putting more and more of your context right maybe this is your medical records your banking information so you can actually do automatic taxes maybe it is actually listening to every second of your life because now that's a full context to enable the best predictions well you don't want that to

201. 2:00:57

     be owned by anyone you don't want it to go to anywhere right so it's extremely important that this is all fully confidential and every single action is secured now as this kind of agentic network you know growing it needs to have a hosting platform where all this agents will live uh we need a way to share the data share them kind of user information so different agents can interact on this and uh assistant is able to uh really leverage it you need to have a way for your assistant to find

202. 2:01:28

     what are the agents out there so agent Discovery and finally all the agents you know they are as we said importantly making money so there needs to be a payment system so one of the things we've been working on is so-call decentralized confidential machine learning cloud right so this is I mean if you've seen my Twitter I talk about tees a lot this is the idea that we can actually run the machine learning model models like the

203. 2:01:52

     llm models as well as any other model inside the secure Enclave The Trusted execution environment in such a way that you have very little overhead uh on the execution and everything is endtoend confidential right not person who runs the hardware not developers not the model builder are able to access what happens inside This Confidential VM and so and so around this you can build a whole Cloud where you have you know uh convential VMS with gpus and uh without

204. 2:02:23

     that actually can run agent code that runs inference on different models and all of this is enter encrypted you need kind of unchain payments and registry to coordinate all this and all of this kind of enables uh this confidentiality I'm not going to go too much into this because it's a agent Commerce talk but uh this is kind of one of the fundamental blocks to enable this now agent hosting we introduced in uh at redacted and since then we've we

205. 2:02:51

     launched uh few hackathons which uh people kind of continuously building more agents really exciting to see over 475 agents now build here obviously there's a lot of example agents is's uh now platform that builds agents itself and uh this is actually the you know think of this as your application store right where each agent is a kind of some capability or uh uh new information or a new way to use uh your users data to

206. 2:03:24

     execute things right this can be anything from a product manager agent to an agent that helps you uh with shopping so if you haven't seen it go to EP there's a way to create agents and uh this kind of platform continues to evolve so every agent here will be hosted inside secure enclaves and so you're able to kind of interact and transact with them uh in a privacy way now what we releasing today is a agent interaction and transaction protocol so this is uh kind of the

207. 2:03:57

     protocol to enable a agents to actually not just talk to each other which and not just call tools but support payments support transactions support exchanging information right and this is extensible standard right this is kind of a new way you know think of this HTTP which enables agents now to communicate to each other in a structured way and it it has kind of capabilities as extensions you can introduce new ones um as a

208. 2:04:27

     developer and you know again think of them as headers in a GTP for developers in the room where you can keep adding more functionality to it and leveraging it for a structured interaction between agents it also supports not just you know one oneon-one agent you can have a whole group of Agents talking together in one effectively chat group and interacting they can add new new agents

209. 2:04:50

     into this uh thread and uh kind of provide you a whole host of kind of capabilities to really create this kind of future where agents are now doing things on a background and you are not really uh directly interactive with this so this is pretty abstract uh I realized and you know so is my many of my talks and uh let's see if we can get a demo going cool so this is demo um so and they way to play it okay I

210. 2:05:38

     guess all right so this is demo where uh first of all you can check out the specific agent we're going to use which is sound Sage is expert in buying audio equipment and so it's deployed already on the kind of hosting platform and now you're going to actually not directly talk to it you don't even maybe know it exists instead you're talking to your assistant right this is the assistant

211. 2:06:02

     that will navigate all of your kind of Internet applications and agent needs and so you go and you say hey I want to shop for you know green headphones it itself has some information already right it's you know it's in the model it has contacts it can actually fetch data uh potentially from other places and so uh it gives you a quick response from that but you can say like no I actually want you know some cheaper agent cheaper headphones and so what happens here you see this like two uh I scroll through

212. 2:06:33

     this but there was the message effectively a sub thread created where a sound Sage agent was called and then the sage sound Sage agent replied back with a whole selection of products uh to choose from and so user selected them and then uh you know as like add pretty much uh initiated by flow which asks them for uh address where to send it again this was communicated to the sound Sage agent and uh you get effectively a payment request and so this payment request you

213. 2:07:06

     know asking for $11 which you can now pay with your uh kind of meteor wallet with your stable coins um and uh this itself will effectively pay the agent which will receive receive this money and then the agent itself will go and uh use Amazon API to actually ship you the headphones and you get an order ID that you can now you know track and so this conversation itself right is an example

214. 2:07:35

     of kind of aitp interaction where some of this was a natural language some of this was a structured data right uh you know specific information to select from products payment requests um uh information exchange for address and all of that was actually done by your assistant in a sub thread with the agent where you just kind of turn interacting directly with your assistant again you

215. 2:08:00

     don't even know there is another agent involved uh we kind of show those sub threads only in the developer side on kind of user side you will not even see that so that kind of the experience that we're going after right where your assistant effectively can go now and find specific um agents who know who have specific skills talk to inform them maybe with some of your context with information that you have uh if we actually go to NE can we go back to

216. 2:08:32

     slides yeah so um yeah so like you as a user you go to your assistant your assistant then uh using you know your memory can either respond directly uh maybe can use some other tools uh or can go to a discovery agent and ask it you know which agents would be useful to reply to this request Discovery agent itself has an index of all agents that are hosted in platform we also want to have actually a Federated model where other agents as well will be contributed

217. 2:09:02

     to this index and in uh this discovery agent effectively says Hey sound sage and this shopping assistant are useful agents for this request let me add you add them to this thread with the user right and kind of remove myself and so then those agents can now reply with you know structured information with maybe clarifying questions maybe with uh you know request for payment or any other kind of interaction like this agents can be effectively uh you know you're

218. 2:09:33

     rebalancing uh uh lending Market agent that now runs every hour to rebalance your portfolio right this can be any any agent now can run and your assistant is kind of coordinating them so that's the idea of kind of aitp to really interconnect all this agents and then discover to help find uh where are specialized agents in the in the ecosystem so to kind of link it back all of this you know um built on top of all of the blockchain infrastructure we've been building at

219. 2:10:11

     near right uh obviously I mean if you've been here before you've uh heard from you know boen to continue scaling the blockchain really need to enable it to handle you know more more more payment requests more and more inter interchain requests uh agents that have their hosting we have shade agents where like you have Smart contract and the kind of the Ste hosting platform interacting together we have a chain abstraction

220. 2:10:35

     Tech which you know is combination of chain signatures and intend to really enable uh this kind of really um simple interaction you know for example you got unboarded uh on base with usdc and you want to pay for something that's in salana right all that gets you know completely abstracted out you don't even need to think about this and finally the te infrastructure that I talked about is cloud that really enables to run

221. 2:11:00

     effectively anything in verifiable confidential way but specifically machine learning AI loads so that's kind of like a multi-purpose you know protocol that we've been building with near over past you know years to really enable this Vision uh and really interconnect the pieces and we're going to do a whiteboard to actually explain how all of this fits um now it's not just kind of near you know near I

222. 2:11:25

     building this there's a ton of teams building like some of them are here uh contributing there's a lot more Partners as well uh that do fit on the slide so really exciting to see kind of all of this community coming together and building now I just want to finish on this last thought which is this is kind of a massive shift in how everything is done in your life right like you go from you know hey I have you know dozens of

223. 2:11:50

     apps that I'm using I'm using you know my credit cards everywhere to really this kind of platform shift that enables among other things to kind of really power everything with Cryptor rails but importantly to transition to effectively a single interface that's on your side that's not trying again you go to google.com google.com is trying to make money of you right you're you're the

224. 2:12:15

     product you're not the user uh the users are advertisers and uh and so this is kind of the platform should we see and that itself right right now that economy itself is a$1 trillion dollars of um kind of a year of business opportunity to really transition into uh kind of this new AI Commerce and user own internet so I'm really excited we're making progress there's a ton of pieces kind of coming together uh it been a lot of kind of building out this protocols

225. 2:12:45

     and systems to enable this but we are now uh see this kind of in production and we have this you know first agents really making real actions in the world we have Partnerships coming together to enable this so really exciting stay tuned I mean stay for the Whiteboard to explain how some of the tech works thank you

226. 2:14:10

     well I don't think we've tried this before right we've never we've I guess long time ago is first right know yeah yeah I think Alex did once uh with Justin Drake like smaller with a smaller group but yeah this is let's just say first time we're doing a live by board uh so you know that said we always do them without preparation anyway and in not one take so this is not that different yeah but uh if you have questions you know raise a hand and we can we can di it so today

227. 2:14:44

     I we wanted to just go over kind of the tax tack we're building because it's kind of getting more and more complex uh as there's more and more moving pieces which are also built by different teams um and uh like all of the different teams contributing effectively into like one master stack that we're trying to enable with this Vision but um yeah would be good to actually have like all of this outlined and yeah if there's any additional questions we can cover

228. 2:15:13

     them so I'll just draw the stack and then we can kind of go line by line so actually something that um long time ago when we started near blockchain we were trying to figure out how to do networking stack and we've implemented a version of it um but one of the challenges generally was blockchain has been there's no incentives on a networking level right you're kind of hoping somebody will give you data and uh there's no kind of way

229. 2:15:45

     to identify if somebody did not give you data or to punish if if they didn't give you data and so one of the protocols we actually released last week uh it's called proof of response and so it's a new primitive that really enables a way to prove when somebody is not responding to you to everybody else so then the obviously we have you know the blockchain itself um we have the chain

230. 2:16:31

     signatures I actually put the tees here uh before intense yeah sure the this is the T Cloud yeah te Cloud we have intents and then we have AIG and I mean there's more things but let's just let's just kind of uh focus on these so uh all of them kind of using stuff underneath or planning to use or uh kind of depend on on what's what's built but also there's kind of maybe indirect dependencies so maybe let's start with proof of response right so one of the again as as I stated the

231. 2:17:20

     problem been okay I am a a malice right and I want to get some data a very simple you know uh question from another node that node doesn't respond to me which can be it's offline or it just decided that it doesn't want to respond to me and traditionally there's literally no way to prove to every to anybody else that this is happening um and so the question was like why is this is important let's start with this well if

232. 2:17:53

     this node stores your data right so let's imagine this is a data storage protocol like on minina right and that node like stores your data there's a proof on chain that it stored your data but then when you actually go and reach out to it it doesn't give you the response it doesn't give you the the data like there's no way to tell to the network that like hey this node is not uh doing this now for our agentic Internet it's even more important because this node can be running some

233. 2:18:26

     agent right and this agent maybe even have some private data uh or access to you know some apis and so again if you depend on this agent for your you know for interactions like this is Agent that rebalances your portfolio and it doesn't reply you need at least find some alternative um and ideally also find the cryptoeconomic way to punish it so what kind of pro response introduces is

234. 2:18:59

     a a network of relayer nodes which are interconnected and so the wi service nodes as well and on each Edge in this network there is some effectively latency and cost and so when I'm when I'm joining the network right as Alice I now specify a path so let's say I'm trying to retrieve some data that uh I want I want my uh request to take and I'm paying a little bit so there's a payment Channel established I'm paying a little bit for this request so what are different cases

235. 2:19:47

     right one case this you know replies back and and uh you know the information goes back to Alice she's happy she paid a little bit for the networking now we have a networking protocol for incentivizing actually information uh exchange now it's possible that this node let's say Bob is uh doesn't want to reply to Alice and for example it didn't actually store the data and uh in this case uh again two options one is it

236. 2:20:19

     replies with just an empty response right like hey uh there is a reply and so Alice like but because it's a cryptographically signed reply Alice can then show to the network hey Bob replied me was nothing for this request you know this is a malicious behavior the other option is it just ignores right and doesn't reply and so in this case the intermediate noes now um are by protocol

237. 2:20:44

     effectively either break the edge themselves with this node or if they don't do it somebody else will break the edge with them right so the the kind of the idea here is that kind of if somebody in this network is not replying right that can be because of the kind of the node somewhere on the path is not replying there is a kind of edge broken now Edge breaking is not like that bad because it effectively means uh you know one connection is

238. 2:21:24

     broken there's a little bit of penalty from the uh from the here you're assuming like the all the nodes on the pass are following the protocol but like it's POS or like at least one note is following the protocol at least one note is following the protocol yes what if they are not following the protocol yeah so we'll get to that we have the you know semi magical solution for for some of this um but yeah at least one notice following the protocol you effectively

239. 2:21:53

     get a broken Edge propagated back to Alice and the idea that like if Bob loses all the edges that's effectively a slash condition because that means that like everybody who is communicating to it it's it's not replying to them right so as more you know obviously like initially Bob has a lot of edges and then Alice can continue you know asking on different path and if B Bob is really you know adamant and not blind to Alice

240. 2:22:24

     it will end up effectively losing all the edges with with all the related notes and in turn getting slashed and effectively in turn proving that it's uh not replying but you need to prove that it has lost all addes yeah so the cool thing is we have a blockchain and the blockchain like all of this doesn't work be like without some way to post all of this topography information somewhere right because like all of this right now is you know if you don't have a blockchain it's just a partially observed information for each node now

241. 2:22:56

     the cool thing is we do have a blockchain where all of the edges are actually recorded as payment channels and so every time you open up a connection you establish a payment channel on chain as well and so you have a full topology recorded in a smart contract and so now when yeah this condition happens then uh the slashing happens um on chain as well and the Bob loses actually someone chain stake that

242. 2:23:21

     they have so this is kind of on one side this itself is a networking stack but on the other side it does use blockchain as a you know kind of this global settlement layer which is what blockchain is really good at now the cool thing is then blockchain can use Pro response to effectively maintain its own networking connections because now again if validators for example not replying uh to the data requests um they

243. 2:23:47

     get they can get slashed not just for like mil is blog production but now also for not being available for data requests which is what you know data availability and all the other things uh trying to ensure uh is there a protocol on how much they should stake so that is I mean up to an application and kind of kind of how it's used I think for blockchain the cool thing obviously the Val taking so canuse that yes for things like you know AB the stack where you know obviously

244. 2:24:18

     it's going to be some economic research I will need to do uh cool so this is kind of again it's a new perimeter like on you know on on a kind of level of like proof of stake enabling you know networking incentivization and verification do you want to talk a little bit more about blockchain Parts yeah I mean has been talked about a lot including in different uh whiteboard sessions um what should we talk about um I mean

245. 2:25:00

     obviously we can talk about the general stuff um so um so basically we have those uh blocks and uh uh we have uh we have a chart uh and uh uh you know each block contains uh chunks from different charts and um important thing is that there's only one chain uh makes a lot of things simpler um and um how the the chunks gets verified uh so since the release nitrate 2.0 release last year is that uh now like on each block um there's a this

246. 2:25:51

     uh this like rotation of Bator is happening um so uh on each block for every chart uh there's a random assignment of validator to charts uh so they validate the state transition of that given shard in that block uh by verifying this state witness uh so the witness basically um is like a kind of a kind of a data that says the state um and then uh proof um so state is basically the state that you you touch

247. 2:26:28

     doing the execution and then prove is proof that the state is actually valid it does belong to the state rout uh so today this is a this is a miracle proof um but the nice thing about it is that it doesn't have to be meral proof any any proof that proves the state belongs to the state root would work so for example in the future can replace that with the knowledge proof and uh that'll be much smaller and um yeah enable us to

248. 2:26:52

     have better skillability um okay so uh I guess we can also talk about the the wrong time uh well I think the interesting thing that we haven't talked much in previous whiteboards is decoupling uh execution from consensus yes um okay that is this um yeah for context Bowen talk about it at the presentation today but not in a lot of detail um because it's very complex um so it is kind of like a something that's already complex

249. 2:27:33

     on its own like you know things like consensus they're by Nature complex but when you like add sharting to it it just become like complexly squared you know um and uh so yeah so so okay let's look at this um so today how it works is like okay you have block produce and like everyone go and process block including like applying the chunks and whatever um and then they're they're basically D here like here they just like like

250. 2:27:59

     basically they wait here I mean assuming let's say like it Block's pretty empty right the it takes like very little time to to apply they wait here until the next block is produced um according to consensus right so what actually happens here is that uh the block producer sending approvals to the next block producer approving this block and then the guy after receiving all the approvals now he has all the approvals to produce uh the next block uh but

251. 2:28:25

     there is just this delay right so during this period of time the node is basically doing nothing kind of like I mean obviously this network connection going on it's like sending uh messages to different notes but it's not spending any of CPU time actually doing the uh the block of the work which is like applying transaction and receipt right so if you think about what the blockchain is is like just like this machine that continuously take like new transactions and and apply them and get the new state but here it's actually not

252. 2:28:55

     doing that job it just there's just this delay here that's idle uh and um people have realized that this kind of sucks meaning that we're not fully utilizing the power uh of every every node so instead what we do is that we say well um we want to better utilize this entire scene uh so basically it's split into uh consensus and execution so so in this new paradigm we still uh produce blocks this way it just that um the difference is here is that after a previous blog is produced you don't

253. 2:29:38

     actually wait for the uh blogs to be applied and for the new state rots to be updated you just like go immediately to the next block trying to reach consensus on what the block is uh so what that actually means is that uh it's basically like every every chunk producer producing some chunk which package the transaction there and they send to the to the broad producer they send the header to the block producer and they the block producer produce a block and

254. 2:30:02

     by doing this um it's basically just like a way to agree on uh what the transaction for like all of the sharts are basically just like ordering and packaging transactions and this just like goes on now and separately there's like execution uh which is like trying to catch up so let's say we have uh just let's say we get everything to work very well we produce block every 200 millisecond so this chain would move forward and then on exclusion basically you're saying like you do the kind of

255. 2:30:31

     what we do today which is like you take block you look at the let's say each chart look at the the chunk and then try to apply it and at some point um this is configurable but some point you're done with applying some chunks you you can say Okay I want to submit this state proposal so on on what basically this is like this this is roughly State root uh after Block H so basically this proposal says um here is a state root uh after applying

256. 2:31:11

     this block and um it submits this proposal and then it gathers this uh validate uh endorsement from the validators by doing this same stus validation that we do uh and then if it has enough endorsement then can be included in a block which is part of the consensus chain but there you're only validating that it has enough enough endorsement um so that's to certify that statewood has been updated um so this uh

257. 2:31:38

     uh This Way um the node is constantly doing uh doing work on like applying transaction and receipt and update the state um and uh you get better throughput this way uh another thing that is I think um somewhat unique about this approach in the sh charting setup is that um generally with charting if you want to have low block time it's somewhat incompatible with a lot of shards because uh the more shards you have the kind of the larger the variance will be between like receiving the the

258. 2:32:09

     chunks uh so uh if if you have that you have if you have to wait for every block to be applied then it's more likely for some trunks to be missed but here um kind of it kind of solve address that problem because one you don't actually need every single block to include a chunk from some sh because it's kind of asynchronous between consensus and execution but also that because you

259. 2:32:32

     don't actually apply it here so it's much easier for like everyone to like keep up with a pace and actually produce a chunk that contains the transaction so it also nicely uh solves that problem um yeah the the other interesting thing is so right now and near you have effectively a limit like one transaction here can only execute for like 200 milliseconds and that's part partially

260. 2:32:57

     because I mean even before we're reducing block time like you you need to give enough time to kind of between execution and uh and you know starting to produce next block and so here if you decouple this right now it doesn't matter how long the transaction actually take yeah like you can you know just order longer running transaction just get updated later yeah and so things like Aurora where you know sometimes like on evm in ethereum actually take you know you know can take five seconds

261. 2:33:29

     to actually execute of real like crunch time right you can actually now apply this uh and it you know can actually take whatever on near it will probably take like three seconds but uh but yeah so you can actually have like longer running transactions on top of already all the other stuff we have is with a sync right where you can you know uh do other things so it's really kind

262. 2:33:52

     of improving fundamentally how yeah like reducing latency increasing band we and uh and in turn also increasing what type of transactions you can do which is already being uh like pretty powerful in there so if I started a transaction like you were just saying that may take two seconds and your block resolution time is faster than it took me to execute and I was using data based on a block that is finalized at the start of the execution is there a method of getting

263. 2:34:37

     the Delta State changes from the blocks that may resolve in between the start and the end of the execution did that make sense so the idea here is like the transaction are queing app right so you can think of this like the consensus part is just feeding the queue of transactions so like every time the block is produced it just puts things into a queue and then this execution just takes it a queue so if there's other transactions touching the same state to same contracts they'll just go into a queue and they'll start executing

264. 2:35:09

     after so to give you an example like let's say there's a you know uh like Aurora transaction one and then then it will like start executing a roora transaction too now because near is parallel you can have like ref executing here y you can have some nft minted in parallel as well but on on the same contract level which is kind of our level of parallelization right now you will have them sequenced and so they'll

265. 2:35:38

     just go into q and wait yeah yeah so indeed really cool I mean really nice so soles a lot of yeah interesting things for near but also kind of pretty Innovative across the ecosystem so uh let's go to change signatures yeah um so this is I guess also connect with Ste so basically um so what this thing is is that um U let's say you have account or let's just say smart contract uh so it can be can be a regular account as well right so uh this is smart contract

266. 2:36:18

     on here um so today just like regular smart contract just the thing you can do is within the near ecosystem right um but what this chain signature allows you to do is that now it suddenly have um addresses on let's say Bitcoin uh on on ethereum on salana um and let's say base um so it uh this smart contract itself has account that it controls all of those chains um it's uh it's a very interesting Paradigm because now what it can do is it literally you can have some logic that allows it to sign transactions for each

267. 2:36:58

     of those chains and then some relayer can go and take the transaction and go and execute on those chains uh so it enables a lot of interesting use cases especially in like cross chain uh defy you know like for example you you want to like Bridge uh Bridge like uh some some token from like one chain to another chain historically the way you do it is like you prove prove that something happened on one chain and then you go and send the proof on the other CH the other CH verify this there's a proof and then it it like does token

268. 2:37:27

     meaning or like unlocking but here like what it can do is literally like it can can just like uh release let's say it it has this address on on bitcoin and it holds on bitcoin you can sign transaction and release Bitcoin uh or like send Bitcoin from that address to some other address uh directly and this is both uh easier to maintain because you don't need to worry about this complex logic of verifying between chains um but also it's actually faster like a native transaction is sent uh the

269. 2:37:57

     latency is basically the latency of the chain of the destination chain um so this is more like from kind of the uh the use case perspective and uh you know near intense for example is a big use case of uh of uh chain signatures and in general like there are people building uh uh multichain lending uh borrowing um multichain Asset Management you can have like one contract that implements some like defi strategy that manages accounts on all sorts of different chains and does like rebalancing you can that can

270. 2:38:29

     even be controlled by like AI agents I can talk about that um yeah so a lot of cool stuff uh can be uh um done from uh from this primitive uh should I talk about how it works maybe briefly yeah yeah yeah um like the final state or current final State yeah so like roughly there's uh some set of nodes uh so it's like MPC nodes uh so each of the those noes roughly they hold uh they hold a key

271. 2:39:12

     share and um uh uh and and the keysher doesn't um so you need a stretch fold is a stretch fold you need stretch fold number of them to participate in a signing request uh in order for to generate signature and the signing request um happens on near so there's like a near it actually runs a near node um that index the chain and when ass signing request is triggered it verifies that it's actually a correct signature request by um that's just SM contract logic but here is to verify the state

272. 2:39:46

     transation is correct so no one is trying to uh attack uh by generating a a bogus request uh and then after got the request it start the special signing process uh which is the threshold cryptography that I won't get into but then in the end the signature is produced and then submit back into the blockchain um and the interesting thing here is that uh we want uh this NPC node to also roll inside

273. 2:40:15

     te uh to make sure that uh uh the key share can leak so generally the problem with MPC uh is that it doesn't have a good defense against the the long range attack meaning that if um if some old set of participants collude they can still recover the the root key and um uh and then everything's screwed uh so uh inside te like you have basically you only allow the key share to be held in un encrypted form inside the te and when needs to be persisted encrypted by the

274. 2:40:47

     te's uh encryption key so that um even if the node operator is malicious there's no way they can get it out uh so it makes it much more secure yeah so maybe that's a good transition to te right so um I kind of mentioned this in my talk as well but uh just like on a high level we have the you know Hardware like for example CPU and so there is a specific way uh where you can actually run a full uh operating system system image

275. 2:41:23

     inside this secure Enclave in such a way that um kind of processes outside this is secure un trust ex environment ver outside are not able to access it right um so traditionally tees have been kind of considered a very hard to use and B very insecure because of two reasons one was that uh the way to run software inside them required to actually write in a special way using very specific API so uh previously it was Intel sgx it

276. 2:41:56

     effectively required to rewrite everything in C it had very low level apis it didn't have for example parallel instructions like SSC um and so it was very limiting what you can do with it plus there was a lot of known side Channel attacks and how to actually extract information from it now since about like March or April last year there's a new uh kind of uh generation of execution environments res in it's

277. 2:42:21

     called TDX trusted domain execution there's a version for irm there's a version for AMD and so those allow to actually run a full operating system image inside this environment and so you can literally prepare you know think of it as Docker you can spin it up there and now what you can get which is really interesting is that when you when some computation is done you get effectively a certificate that this computation was

278. 2:42:46

     done in this data and importantly only is it computation was done there was no other computation done on this data which is really important for a lot of the use cases which just talked about right because if you think of uh you know the NPC that bone described well you want to know that only the calculations that you asked NPC to do were done and nothing else right it didn't try to extract the key didn't you

279. 2:43:12

     know do anything with it and actually maybe even deleted it so that this chart is not even uh valid anymore going forward forward because it doesn't exist similar Pro of response right this ensures that nodes actually following the protocol in the whole network of the nodes that following the um te so there's a there's a kind of this concept of quote uh which which te can return and so so on top of this primitive right

280. 2:43:38

     there uh kind of um there's a few different bits and and pieces that are being built to enable this uh so first of all there's kind of reproducible Docker builds um that kind of uh especially file Network been pioneering on how to like make it really easy to uh distribute uh software in verifiable way so you actually get uh effectively like you can upload a specific Docker container which you know the hash of which is known and it's consistent and so you can actually you know look at source code verify that the source code

281. 2:44:12

     is not doing anything malicious reproduce the docker compute the hash and when you do some computation it actually proves to you that this hash of a Docker is running inside te right so that's kind of basic primitive you get this Docker container was run inside te on this execution and only this thing was done now kind of uh what this allows to do uh Kendall was talking about is the concept of shade agents right where now you can actually

282. 2:44:43

     call for example this the some execution and then go back to the block chain right and post that hey these calculations were done um on this data and this is the outcome right and so your smart contract can effec receive outcome verify on chain that this you know quote is correct that you actually have indeed used this done this execution inite te on this data only this thing was done and this is the outcome and now

283. 2:45:17

     this outcome can be used somewhere in smart cont to give you an example you want to build this rebalancing portfolio you have the chain signatures to hold assets and all chains but who does rebalancing right like what is the logic of rebalancing well you can actually run arbitrary computation for example go read Twitter you know uh fedge data from kaido decide on a new allocation in the index and then return back this new allocation right and then you know maybe

284. 2:45:41

     it does like some cross checks on a smart contract level and then verifies that indeed uh let's execute that rebalance yeah I think an important thing here to know is that there's a way to verify this attest station without going to Intel server basically there's a database that they publish that can be put on chain the database of certificate that can be put on chain and then that can be used to verify the attestation

285. 2:46:05

     which is what uh shade agents do yeah and similarly like if you are a you know our proverbial Alis who wants to do some computation offchain right uh she can connect to this node through TLS so through encrypted connection so this node exposes effectively it's a certificate proving that it runs with the same Docker and so then you can encrypting with this with a certificate communicate some private data that again

286. 2:46:35

     this node let's say this is our semi malicious bulb cannot see whatever the data come coming in what happens inside so some computation is done and then the response comes back again with this quotee right so now you have a full entn confidential effectively computation done in on remote server and you know that only the computation was done for example removed all the data afterwards

287. 2:46:58

     it didn't save it you know that you know it run exactly as a AI model or a CI agent and uh you get back kind of certificate that the answer uh is this right so this enables effectly both onchain and offchain actors and of communicating with a uh this te node to really uh do conf calcul computation in offchain case or verifiable in in the onchain case the uh so kind of but this is like a single note right so okay what what what

288. 2:47:36

     happens when there's like lots of this noes how do you actually um how do you actually manage this well this is where um proof of response comes in right because the reality is like there might be some node and when I say like this is you know any arbitrary Docker I mean it meaning we for example spawn up our like pogress like database running inside te right so you can actually literally have

289. 2:48:00

     a private state for your shade agents onchain agent have private State running inside te that you you know you trigger do some calculation and the output becomes public on chain or private on chain right so like it's an arbitrary like complex uh software that runs there and so now you can have lots of these uh te nodes that join the network um they will need to stake something to participate in proof of response and so now you can actually

290. 2:48:30

     have um an ability when you send a request to prove that one of them is offline or not right so this gives you kind of this liveness guarantees from a network of verifiable nodes and so you actually have a fully verifiable live Cloud um obviously like if the node is offline you need toly reroute to another node so there needs to be like additional protocol uh like for kind of load balancing the work etc but overall this gives you kind of a verifiable cloud something that you know if you've

291. 2:49:00

     been in crypto in 2018 everybody was promising you this is actually it offers uh effectively a system to to achieve that by combining proof response T Cloud using blockchain and then obviously leveraging chain signatures to go multi-chain yep all right so if you're not bored yet we have more stuff so all of this is cool um the next level of this is the idea of intense so intent is really more from a user perspective and kind of higher

292. 2:49:39

     level developer perspective if I have some requests right and I actually don't want to figure out how it should be done right so this is like hey I want to rebalance this portfolio I don't want to actually figure out exact you know swaps that needs to happen I want somebody else to do that right so you can communicate with request so here you have some way of communicating so for example this can

293. 2:50:03

     be centralized running inside te this verifiability this can be our decentralized te Cloud where where this propagates and so you have other parties which can be either verifiable or not so this can be some you know uh like friendly face and this can be some things that's running inside te that can respond to this saying like hey oh you want to execute this complex procedure I will do it for you and you know this will cost you this much and I'll do it

294. 2:50:32

     in this long right so the simplest example of this obviously is you know swap one Bitcoin for whatever 100K usdc somebody's like cool I'll do it maybe you know 99 500 somebody's like no no I'll do it for 100k and the cool thing compared to usual blockchain where you would submit this request on chain and then effectively now everybody can observe it and and you have minor extracted value uh where people try to front run it here because it's a private request and you're actually getting the quotes you're getting the kind of hey

295. 2:51:05

     you know how much you would do it so it's an interactive protocol you choosing the best option right so there's no way to front run you because you choosing what's the best option going to be and then you already submitting effectively two like two signatures your signature and the solver signature on chain to actually set like so like to commit to this outcome right now this protocal can be a bit more complex there can be like some escro

296. 2:51:35

     time uh where you know there may be dispute because for example you said you know build me build me a building there five floors it said like okay cool it's going to take a year and I'm going to do it for whatever uh million and so this $5 million are actually going into escrow and then if the building is not built there's a way to resolve that and get the money back right so simplifying

297. 2:51:58

     but that's kind of uh allows you to have this complex offchain negotiation protocol figure out what you want to do submit this start executing and disputing te offers you like additional benefits because now for example uh you know who doesn't like launching new tokens well you can actually launch a new tokens inside te itself so you have new token on chain so XYZ token and so all of the CL token is owned by the account inside this te and so when

298. 2:52:29

     people want to buy it the te is actually Market maker right so you have a fully like confidential and also verifiable you know exactly how it works Market maker right so this can be as simple as you know your un swap formula or this can be as arbitrary as you know have you tweeted today about this token then you're allow to buy right it can be arbitrary logic that actually runs here as a market making logic that actually

299. 2:52:55

     responds to requests from users so this actually solves one of the fundamental problems with blockchains where when even however you paralyze it if people are trying like if you know 10 million users are trying to Target the same piece of State because everybody wants to try trade trump it doesn't matter how you paralyze it that piece of data is congested and so this actually allows to

300. 2:53:17

     have you know you can arbitrary scale this number of tees that can respond to this request that control the supply and so they can all effectively reply uh to different users so you can actually have a scalable like uh Market making fully verifiable through the te and the reply in your intents yeah I think the the interesting thing here is it doesn't it's not limited to like uh you know trading tokens or like swaps it's it's

301. 2:53:44

     more General and then it can be extended to things like Commerce and like just like buying a laptop or whatever you want to do yeah so the example showed I mean this is more going into ATP already but yeah you can say hey I want to buy headphones somebody's like well here are some options for you right an agent replied you're like cool I'll select this option let's go to the you know process we askc for the money and then when the product arrives right we resolve it or dispute it if it didn't

302. 2:54:10

     arrive right so this actually allows to do like more traditional Commerce in this way and like General payments infrastructure you know think of credit card payments but now down through those flows um and again because you have guarantees you can have guarantees on some of this other side as well you can actually do a lot of new things uh in this way yeah it's also very flexible

303. 2:54:33

     can do like OTC and like they still use same framework to settle yeah it's not like just like x times y = k it's very flexible this can literally have like you know a Twitter white list it can have you know like arbitrary formula of Market making Etc so but it's also can be like any arbitrary AI code that runs whatever right so that's kind of the idea is like this is we're effectively moving from trying to fit everything into blockchain to effectively have like

304. 2:55:02

     an ec2 level verifiable compute that you can like inter leave with effectively like arbitrary requests and responses through this network so and so on top of that we build effectively the agent stuff where where these agents are now communicating with each other and so ITP is really just conglomeration of all these products right where it allows effectively one party to initiate some communication uh and then parties to exchange you know structure data like

305. 2:55:35

     okay I want you know request some data from you I want to request signature so let's say this is Agent B this is Agent a and you have maybe like uh user and so kind of the idea of ITP you can have like multiple of this parties in the same conversation and some of those gets replied directly by agent a some gets propagated to the user so have like a full flexibility of effectively decomposing intents into like any number of participants and kind of exchanging all this in one communication the cool

306. 2:56:15

     thing is because it's kind of maintain think of it as a thread or as a email thread you can then if something like if you have a dispute right let's say product didn't arrive agent didn't do the good job you can effectively add like another dispute agent for example who joins the thread and like okay what happened here like what did you promise what what's the what's the process Etc and this itself you know can escalate to like

307. 2:56:37

     court because this has like a full like conversations logged as well that is only shared between these parties until New parties are join so kind of aitp effectively creates like this overlay over all of this to kind of on the on a like a gentic level to kind of join all this pieces together and enable them to trade Converse and interact as well as you know do business do uh kind of transactions exchange private data uis

308. 2:57:08

     and other other parts so point is all the pieces effective working together uh they all build on top of each other and we're effectively enabling this you know Vision to talk about like how AI is actually going to be your interface through the uh through web 3 and web two and all of the pieces are really kind of powering that future yeah very exciting and still still a bunch to build but we already see I mean you saw the demos I

309. 2:57:43

     think we have more demos actually kind of want to show more demos but uh yeah all right we're at of time so it's time for drinks thear time for drinks you probably need a drink after this so I understand all right iot B thank you so much uh yeah ladies and gentlemen as you have just heard uh there's going to be a lot of booze so you can go and get as drunk as you want to get um if you love that as much as I did it will be on uh YouTube it will be on Twitter it'll be

310. 2:58:22

     on Facebook it will be on only fans uh LinkedIn Tinder wherever the videos usually are um so you'll be able to catch up with that in just a few hours but uh until then please if you could stand up because we need to move the tables about and and get like everything all sorted uh but we are back here tomorrow