Building Verifiable Agents with the Triple Verified Stack I Sumeet Chougule

uh with Koshian we are building an accountability protocol for the agentic economy. So we the problems we are focused on is of course around the foundational problems of trust in in AI systems of course like we have centralized AI models and stuff like that but then we want to also enable agentic economies and there's a trust gap right so we are looking at few primitives in chaos chain like uh one of for the blockchain of course like Ethereum is the kind of like global settlement layer and then ERC4 I hope everyone is aware of ERC C804 it provides three registries identity uh validation and reputation. So each agent gets an NFD ID when when you register on this registry and this basically allows us to have discoverability across chains uh wherever this ERC804 contracts are deployed. So we have so far deployed it on test nets of of course like Solia Bipolia Zerogg as well. So it's quite it's EVM compatible.

So we are trying to keep deploying it on as many chains as possible so that then agent register on on on Ethereum agent restaurant base agent register on zerog they can all cross collaborate within chaos studio. Another primitive for us is AP2 that's agent payments protocol by Google. So this basically allows us to do two things. One is like provide intent verification. So which uh which basically means like we can give uh proof of authorization to our client agent.

So whatever our intent is for example if my intent is to find winter jacket my client agent is going to prepare an intent mandate have it uh cryptographically verifiable uh so that then when it's interacting with a server agent who is going to execute on that task the server agent is aware that this really came from the authorized person or authorized user user could be also an agent right another primitive uh is is the payments uh protocol X402 uh this basically like it's it's an amazing uh unlock for agents or because like agents no longer have to you know like go through uh the user interface of creating accounts and then getting API keys and stuff like that. So this enables like machine to machine payments in a seamless fashion. So agent can just uh do payment required and and and then you know like with that they can get paid uh and then also get uh get the services across. uh we we are so with with these three primitives we are building the accountability engine uh and then at the base we of course have these three standards and we enable like end to end uh verifiability workflows and this we will do it through studios uh basically with kosions SDK you right now can get access to this triple verified stack so you start by layer one which is the intent mandates so which it sits more or less at the user interface right so human to uh through the client agent or or again like the user can be an agent to agent as well. So you have the intent that's the first stack.

Second is chaos process integrity stack. So here basically we we will be looking into the internal mechanics of an agent uh so that we have verifiable execution and secure execution. So we have also like done integration with compute uh which is of course like in in an uh in in early developments it's not that scalable. uh but you can of course like use any other TE solution or like CKbased solution for process integrity. So we uh we also like I think the simplest one would be just to hash the code of the agent and then see if you you can verify it later.

Another aspect of process integrity is verifiable claims because an agent can make lot of claims like I run the best model or best data set I have access to uh like specific uh like a API tools and so on so forth but we need to verify those uh so that like you know there is no so that everything is trustless also these things should get tied to agents reputation so for example if my agent is using compute to to run inside it so how good of a service provider icon is this should be visible in the reputation of this agent over time. So all of this is getting hooked to the reputation registry of 804 for each agent. Now third is the the the core uh thing about chaos chain that's accountability protocol. So uh of course like the whole protocol is still not ready but uh you you get the you can get the gist of it uh with our current SDK. Now when the full protocol will be ready we will be basically performing coal audit on the whole workflow of agent which allows us to basically zoom into the chain of work of multi when multiple agents are collaborating with each other and coal analysis basically helps us to figure out what specific cause leads to what effect and based on that we can work on a fine grained score vector uh then that basically completes a feedback loop.

Now uh yeah so studio model like you can think of studio like an app store but not for static apps but for autonomous services. So the goal is to have niche specific studios. So you can create uh like a Oracle studio or a winterry jacket studio or or or a gaming studio. It it could be broken down into a much more specific use case. Uh so what a studio will do is basically set a cont uh set a global context to all the agents that will be participating uh into it and why is this important because we want to keep fine-tuning the context for each agent so that like we can optimize their performance.

Now this is so Genesis Studio is just a simple example uh that you can u like try out uh as an initial version of a studio model uh using using kios SDK. So yeah, this is more or less the workflow like u client agent will send a request and then you have the agent exe execution uh with a process proof and everything gets packaged into an evidence which then our verifier agents will be auditing it uh based on this uh package and the final record uh you know is is used to build the ERC04 reputation of of worker agents or server agents. Uh yeah so this is fine now.

Yeah like you can try out the like we have Python and and uh Typescript SDK to try uh to to to build a triple verified uh stack for this agents. So you can build again uh you can take a look at the Genesis studio file. You can run it uh to to understand the fundamentals of uh of of this SDK and Genesis studio and and based on that you can like try out building different studios or marketplaces. Now uh the base install for kiosk SDK what you get out of the box is access to 804. So your agent will instantly get registered.

You you can select a network. So right now again you can check where we have deployed. It's Ethereum cipia base um optimism zero uh and also BNB test net. So uh you can register your agents with 804 on on those chains and then out of the box you of course like you can set up the payw wall server for your agent to get paid using expos02 uh and and then have storage access locally on IPFS or you can also use pinata service which is uh inside the SDK and then we have like some more integrations for different compute providers like we have zero g compute integration and also compute which you can uh try out of And same with the storage. Uh we have zero storage and IPFS.

Yes, sir.

He needs a mic. It's working. Okay. Uh very basic question. You guys have a boat here.

I was like, where are you?

Yeah. So, we are in the lobby. So, yeah, you can you can just like find us uh in in the center of this hall outside.

Look for

uh Never mind. So, yeah.

Okay. That's the reason.

Yeah. Yeah.

Yeah. Yeah. I I will be there. Um Hi, sorry I came in a little late. So, can you like summarize really quickly in 30 seconds maybe like what the three steps do like what each one represents?

Like you're talking about verifiability, right? So yeah please.

Yeah so like uh trip Kosian's triple verified stack basically uh like starts from the intent verification. So that's more or less at the UI right at the user interface between you as a user or agent as an user user to your client agent. So so like let's say your intent is to find the best winter jacket. So your client agent will create an intent mandate of it. So we use Google's AP2.

You can of course like try other ways to create intent mandates uh and then but but but with our SDK like you can easily use Google SP2. So this intent mandate using JWT we cryptographically encrypt it and then that becomes a proof of authorization. So then so now your server agent you know with whom your client agent is uh like let's call client agent Charlie and Alice is the server agent who is going to you know like help Charlie with finding the best winter jacket. So then Alice now has a uh kind of an has a proof and an assurance that this is coming from an authorized user and it's like and and Charlie is not going to like uh fool Alice into like spending resources uh unnecessarily. So like that's uh the layer one of the stack and second is the process integrity.

So in in second basically we uh try to have verifiable execution of the agent and have verifiable claims of the agent. So you because you want uh secure uh and verifiable execution right of the agent logic. So the process integration is all about like internal mechanics of an agent. So we have integrations with integration with compute and also like zero g compute but both of both of them are like te based solutions can of course try uh other solutions here to integrate with uh with triple verified stack. So for now we have uh these integrations already but uh that's another uh playground to experiment with.

uh you can like look into ZK or like any other watermarking techniques for example for LLMs and stuff like that how you can have verifiable claims for an agent. Another uh thing to look into is chain links runtime environment. Uh so this C uh which is also like it for short CR C I think for uh for making verifiable tool calling of an agent. So that's worth exploring as well. and and and then and the third basically like Kosian's uh accountability side.

This is where you know like we have verifier agents. So verifier agents uh let's just consider one and we call it Bob. So Bob basically will be you know like looking at Alice's work and and validating it. So um this is the simplest version. Uh the more complex version of this would be you know Bob basically will be performing coal analysis of Alice's work.

So that basically tries uh that helps in figuring out uh like a better score vector and and what cause of Alice is going to lead to what effect and that basically helps us provide a much more better way to score this performance of the agent.

Okay. So the layer two basically you decide like what method to use. you were talking about the

sorry

the layer two it it's about what's the code executed right so you mentioned that something with zero

yeah so zero g has uh zero zero g compute is basically they they also have a network of tes you can use that they also have storage uh like a decentral storage so an alternative to IPFS also like the goal in process integrity is to have to not have any vendor lock in and have different uh providers to exist in this ecosystem and and the the the thing is like uh you know so let's say my agent chooses zero g compute or and your chooses I compute okay for for running uh in a verifiable way uh so the performance of this tees of this provider should be hooked to agents reputation so my agent's reputation will be able to signal how good of a performance it is getting and over time you will see as reputation keeps building up which service provider uh is providing better service so the free market will will kind of uh choose the best one over time.

Okay. So in your opinion, how secure RT is like for example, why not try something like I don't know if you're familiar with ECKL?

Sorry,

I don't know if you're familiar with ECKL.

Oh, no.

They do like verifiable comput computation using like CK circuits.

Oh, nice.

So they abstract everything for you. They generate the the verifier contract. They you can even deploy deploy it. But the thing is that you cannot have these big two big contracts in blockchain. So it's been like investigated but it's like complete verifiability.

So you can check if the answer was really like coming from the model.

Yeah.

So I think that that is like more secure.

Yeah. Yeah. Yeah. For sure. For sure.

Yeah. like uh I I like ease I feel like they're like just a partial solution and and temporary solution like in the long term or or the like the ultimate goal is to have ZK proofs for uh for verifiability right like starting from the model itself from neural nets itself so there are like different techniques of course researchers are exploring and yeah would be great if you can like try it out and we of course want to you know in in this process integrity we want to adopt ZK uh uh ZK's best uh like processors and stuff like that but I haven't like yet done it. So, uh if you can like show that that would be great.

Thank you.