AI adoption of Grin

[trab]

Just opening this thread to discuss ideas. Posting @Yeastplume ‘s ideas first to seed the conversation:

@Yeastplume

Grin and AI

You might have noticed people using terms like “AI” or “LLM” over the past little while :D. While Grin has always been about simple, private, human-to-human transactions, it’s worth thinking about how it might fit into this emerging world. This is all highly speculative and based on a version of the future that might not come to pass, but I think it’s worth considering.

In particular, there’s a lot of buzz around ‘Agents’ and agentic workflows. These are e scenarios where autonomous AI agents perform tasks and interact with other agents or systems. Think of things like:

• AI purchasing cloud computing resources for itself.

• AI agents collaborating on projects, compensating each other for contributions.

• AI agents simply exchanging the costs of LLM calls with each other.

Personally, I’ve heard some buzz around the merging of cryptocurrency with AI, and I think Grin could fit very well into this world, particularly due to its inherenet privacy and multy-party transactions being a core feature.

I’m not saying AI is the future of Grin or that we need to pivot everything in this direction. But given where technology is headed, it seems worth at least exploring how Grin might play a role in this space. There’s potential here to position Grin as a tool for new types of use cases and maybe spark some fresh interest in the project along the way.

For instance, we could look into ideas like:

1. Wallets that AI agents can use autonomously - or “The LLM Wallet”. It should be possible to do this securely using local LLMs and secure function calling that doesn’t expose any passwords or wallet info.

2. Using Grin in AI-driven marketplaces for trading resources or services.

3. Privacy-preserving payments between AI agents, which fits naturally with Grin’s design.

This is still very much an idea in the exploration phase, but I think it’s worth trying out a few experiments to see what’s possible. It doesn’t need to be a major focus, but I think it’s an area with potential to keep Grin current and relevant as technology continues to evolve

I’ll share more thoughts and updates as I dig into this, but for now, I’d love to hear what others think. Maybe this opens up some interesting possibilities we haven’t considered yet

I’m seeing similar solutions pop up elsewhere. Introduction | Recall Docs

It reminds me of Nostr: If the monetization can remain currency-agnostic on a protocol level, Grin can take advantage of that.

[yasabi]

Entropy is another project exploring this general area, their lead dev Tux is pretty rad as well.

[Anynomous]

The part that I do not have clear regarding the potential use of Grin with AI agents is how it can interact on the data level.
Sure, Grin is good as streaming money, its interactivity might actually be great for AI agents, allow easily iterative building and distributing of reward, but how do you link that to an generated data/model output? With most BTC like blockchains you can anchor anything with a hash on the blockchain, but for Grin you cannot do that as far as I am aware. Perhaps there are a few bytes in the range-proofs you can use for that, but I do not think any other arbitrary data can be put, hence Grin cannot be used for ordinals for example. Does anyone has ideas how grin can be linked to off-chain data/models/AI-output?

[tromp]

@Anynomous

for Grin you cannot do that as far as I am aware

Sure you can. A public nonce R that’s of the form

R = R’ + G * hash(R’,m)

commits to an arbitrary message m. You can see this same mechanism used in Section “Proof type SenderNonce” of Grin’s payment proof proposal [1] and in Bitcoin’s taproot.

[1] grin-rfcs/text/0000-early-payment-proofs.md at early-payment-proofs · tromp/grin-rfcs · GitHub

[Anynomous]

Cool, the miracles of crypto never seize to amaze me. So you can basically commit to anything.
Is the public nonce R a private-key that is public, shared with others so they can verify the commitment?

[tromp]

@Anynomous

never seize

To cease (as in: cease and desist)

@Anynomous

Is the public nonce R a private-key that is public?

The public nonce R corresponds to the private nonce k as R = k * G. The kernel only shows the public nonce, which is all that’s needed for verifying the signature.

[Yeastplume]

You have the LLM interact with Grin / Grin Wallet at the API level via the concept of ‘tool use’, which is basically function calling for LLMs. For instance, you register the wallet’s API functions with the LLM via a system prompt, and let the LLM decide when it needs to call out ot them based on its interaction with the user.

For instance, the user might say ‘what’s my Grin balance’, and the LLM’s chain of reasoning goes 'I need to call the ‘get_info’ function with these n parameters, it does so (bascially, the LLM prompts ‘you’ to call something and return the result. Your agent’s code calls out to grin wallet, gets the response, and then displays it to the user or alternately inserts the response into the conversation thread to return to the LLM.

The trick here is constructing the flow of the conversation and tool calling to ensure all private data /authentication etc is kept firmly on the client side and never put back into the converstation thread, particularly if the LLM on the other end is a big public 3rd party one. Or there are plenty of private LLMs whose reasoning is already sufficiently advanced to handle a grin-wallet agent, provided you have the horsepower somewhere to run them. The agent developer also has total control over when to get a human in the loop before attempting to perform operations.

If I were doing this right now, I’d be trying to create versions of specs for the grin and grin-wallet APIs in a format such as this: GitHub - OAI/Arazzo-Specification: The Arazzo Specification - A Tapestry for Deterministic API Workflows, which is intended to capture both the mechanics of function calling and the LLM prompting in a single spec. If this existed, it would be a relatively simple next step to go from there to a basic grin/grin wallet agent. Then you could have wallets communicating with each other via their agents, sending slatepacks back and forth, and then move to a world where agents whose primary functions are things other than grin need to agree on a method of value exchange, can plug right into grin agents for those needs. Possibilities like this are why I think Grin is very well positioned to insert itself into the AI/Agent space, with a bit of imagination.

[Anynomous]

Sounds interesting, do you also have a particular vision for grin use in iOT?
What is currently missing on the side of grin? E.g. Are payment proofs ready for this vision, would there be a need for multisigs or other features not yet active on Grins mainnet to realise this vision?

[011]

This AI looking dude just dropped this a few days ago.

https://x.com/ManusAI_HQ/status/1897294098945728752?t=A7OA581DeWcDXDFIDg_pTw&s=19

Seems like it can do stuff:

https://x.com/Maheshbr4U/status/1898265991185838374?t=U-1GX1AiBMc_IT5yK2oWIw&s=19

[011]

RIP internet. Year of death: 2025.