Transcription: OpenAgents Episode 169 - Agent Payments API

Source: https://x.com/OpenAgentsInc/status/1919419077887410389 Wiki source: https://raw.githubusercontent.com/wiki/OpenAgentsInc/openagents/Video-Series.md Media title: OpenAgents - Episode 169: Agent Payments API At this weekend's @PlebLab hackathon... Upload date: 20250505 Transcription model: gpt-4o-transcribe-diarize Generated at: 2026-06-01T04:29:22Z

Machine-generated transcript. Review speaker labels and wording before using this as quote-grade source material.

[00:00] Christopher David: And we're back at Pleb Lab.

[00:01] Christopher David: How's it going, everybody?

[00:04] Christopher David: We are at the rusty vibe coding A.I. something something hackathon and we're here to introduce the open agents A.P.I. Um this is uh way less mature and stable than the zap right A.P.I._ So if you don't think it's something stable and mature and production ready zap right's the way to go. If you want something bleeding edge and like you'll find some bugs that are hilarious but you'll build cool shit um yeah, use the open agents A.P.I_ Same prize purse deal um

[00:31] Speaker B: Mm.

[00:31] Christopher David: um as zap right so this is available now our docs uh on our new site at openagents.com you can check this out i'm going to step through it um the big idea here is we want to let you transact money

[00:47] Christopher David: to and from agents as easy as making a single API call.

[00:51] Christopher David: We are building on top of the just released Spark SDK from LightSpark that came out a few days ago.

[00:57] Christopher David: It's like a, they call it a layer two. It's really a state chain that kind of like sits on top of Lightning in some interesting ways that enables a few things.

[01:05] Christopher David: Like if you want an agent to send to another agent and it's sort of like within the same ecosystem or just really any agent that's using Spark,

[01:12] Christopher David: you can send agent to agent.

[01:14] Christopher David: instantly with no fees whatsoever and not even to worry about channel liquidity so that's a nice feature to kind of add and everything's got exit to lightning exit to bitcoin if you want to

[01:24] Christopher David: So let's go through a few things. So let's just start off.

[01:27] Christopher David: This is my like draft blog post. We're going to be like announcing this formally on Monday.

[01:30] Christopher David: And my hope is between now and then I'm able to like showcase some of the cool things that you guys build in this post using our new agents payments API.

[01:39] Christopher David: So my favorite quote we'll start with from Michael Saylor is the AIs are coming.

[01:44] Christopher David: The AIs don't get bank accounts. They don't get credit cards. The AIs, the artificial economy,

[01:50] Christopher David: intelligence economy will be built on digital capital.

[01:52] Christopher David: digital property.

[01:53] Christopher David: It will be a hundred trillion dollar economy.

[01:56] Christopher David: It will be built on Bitcoin.

[01:59] Christopher David: Obviously, this is going to require agents to be able to be economic actors and transact with Bitcoin.

[02:05] Christopher David: There has not really been an easy way to do this, I argue, until now.

[02:10] Christopher David: We have this amazing thing that we're building on top of called the Spark SDK. We've been sort of alpha-beta testing this for a number of months.

[02:17] Christopher David: They just launched to mainnet like three days ago.

[02:20] Christopher David: Carr asked me to put together an API,

[02:22] Christopher David: something for you guys to chew on this week.

[02:24] Christopher David: And I was like, all right, well, I'll build an API on top of Spark.

[02:26] Christopher David: of Spark.

[02:27] Christopher David: You can always build directly with Spark.

[02:30] Christopher David: They have only right now a Node.js SDK for server side. They're in the process of doing a Rust one,

[02:37] Christopher David: but it's not like to parody of their Node.js one.

[02:40] Christopher David: But I was like, okay, here's where I'll just like throw an API on top of this.

[02:43] Christopher David: You can consume this from any application.

[02:45] Christopher David: So if you're coding today and your backend is in Rust,

[02:47] Christopher David: you're able to easily use our APIs for this.

[02:51] Christopher David: And

[02:52] Christopher David: You know, you might think that you can um if you're like new to developing make sure you know that like anytime that you're dealing with secure credentials it's important that you not include them in the client side uh so even though you could be making HTTP requests from the client side, maybe that might help you during the course of like a hack-a-thon, just kind of proof stuff out, um basically never deploy your your keys to to to client side. Um okay, so a couple of things here. Um

[03:16] Christopher David: Let's go through the docs.

[03:18] Christopher David: So super simple. In this case, our agent's API,

[03:22] Christopher David: this is largely just table stakes. It gets you a thing.

[03:26] Christopher David: There's no agentic behavior here at all.

[03:28] Christopher David: So the only relevant thing that you can do here is have a thing that you're going to have access to a wallet.

[03:34] Christopher David: The relevant thing here is in agent payments.

[03:36] Christopher David: So you can do a few different things here.

[03:37] Christopher David: You can create a wallet for a given agent.

[03:40] Christopher David: You can check its wallet balance.

[03:43] Christopher David: And you can do payments either through Lightning or through Spark.

[03:48] Christopher David: So let's say that you want to be able to create an agent that presents a Lightning invoice to the user because you want the user to fund the agent.

[03:56] Christopher David: You'll do create invoice and you'll get back a Bolt 11,

[03:59] Christopher David: render a QR code in the way that you're used to doing.

[04:02] Christopher David: The user pays,

[04:03] Christopher David: the agent balance will be instantly funded.

[04:06] Christopher David: Now hopefully with that agent that you have that has a balance,

[04:10] Christopher David: hopefully you can now think of some interesting things to do.

[04:12] Christopher David: Do you want that agent to be able to pay an invoice?

[04:15] Christopher David: And here's where you're going to use your tools like Cursor, your tools like other LLMs that you probably have access to, you know, all of the very many multi-billion dollar labs that are throwing credits and stuff at you to be able to make it easy for you to do LLM type things.

[04:28] Christopher David: Use the Vercelli AI SDK,

[04:29] Christopher David: throw this into there,

[04:30] Christopher David: maybe you're going to just create a tool around this.

[04:33] Christopher David: And now you have an agent that's able to make payments very easily.

[04:37] Christopher David: If you're wanting it to kind of transact through the world of, you know, other Lightning-enabled services,

[04:44] Christopher David: these agents can all pay invoices.

[04:47] Christopher David: And then there's like one subset of cool things you can do with that.

[04:50] Christopher David: There's another subset of cool things that you can do with sending payments to other agents.

[04:56] Christopher David: One thing that if I'm going to be judging and looking for people who are using this in the coolest way.

[05:00] Christopher David: A, ideally you're able to do something,

[05:03] Christopher David: you know, picking one of those two things or maybe combining them where you're interacting with the outside world using the Bitcoin payments.

[05:09] Christopher David: But then I'd love to see some cool new applications around agent to agent commerce,

[05:14] Christopher David: particularly if you're able to work with some of the other people that are also building on this API.

[05:20] Christopher David: All of these agents have Spark wallets. When you create an agent,

[05:25] Christopher David: then you create this wallet and I'll demo these endpoints in a second.

[05:30] Christopher David: You're going to get back an identity that's a public key.

[05:33] Christopher David: So you can use that for, you know, attaching a Nostra metadata to it if you want. But most importantly, you get a Spark address.

[05:39] Christopher David: The Spark address is globally, like anybody can send to this Spark address.

[05:44] Christopher David: So maybe some of you make like a little web page and your agent has an address.

[05:48] Christopher David: address that some other agent can talk to,

[05:49] Christopher David: or you don't even,

[05:51] Christopher David: you skip the web page part and just do this all as MCPs.

[05:55] Christopher David: Okay, so in terms of using this, you can kind of like look through these docs. If there's anything like confusing about this, please let me know. Obviously this was kind of like thrown together rather quickly. I did basic testing of it to make sure that it works, and it does.

[06:06] Christopher David: Uh, we separately also have an OpenAgent's API uh Jason, I gotta add the link still to the docs, but if you go to openagents dot com slash openapi,

[06:15] Christopher David: you can also just do openapi dot json, it'll both take you to the same place. Oh, that one starts pretty uh uh pretty bright. So you basically can just doub dump this into any application.

[06:24] Christopher David: location and have it working. So let's actually try this out. Uh first, let's just go to chatty BT and ask 4-O uh like summarise this and what's possible. I'm just gonna pretend that I'm super new. What's possible and how do I use it?

[06:38] Christopher David: I'll be floating around during the hackathon, you can always come up to me and ask questions. And certainly if anything is like not behaving the way that it seems to from the docks, please let me know. Uh but let's just step through what chatty BT thinks is uh, you know, what this A_P_I_ makes possible. Here's the summary.

[06:53] Christopher David: Uh the open agents API lets you create and manage A_I_ agents, give each agent a wallet, send and receive lightning payments through agents. I don't even know that it that knows what Spark even is. But that's one of the other endpoints. So uh create agent, list agents, get agents, basic stuff. And then wallet management, create wallet, get balance. And then payments uh create and pay invoice and then when it says here send sats. Gosh, I think that it's just for Spark this one here, but maybe it's maybe I

[07:21] Christopher David: Maybe the ARIA task with this did a more thorough job than even I asked it to. Okay, so uh for authentication, you need an A_P_I_ token, you're gonna get that for free on our website. There's a page on the docs called authentication. Um you'll see this.

[07:37] Christopher David: In a second when I step through the flow, you just click generate A_P_I_ you sign up with just an email and a password, there's no verification or anything, I don't care who you are, just, you know, free account, email password, you generate an A_P_I_ key, that's what you use for authentication as a bearer. Now you'll be able to copy uh things like this and then swap in your credentials. Uh this is just kind of like a dummy thing, this this signature doesn't do anything, but if you go to agent payments um you should see all the information that you need

[08:04] Christopher David: For the actual like copy pastable URL it, you know,

[08:09] Christopher David: that will come to our doc site in the next few days probably. But for now just ask chat T_P_T_ or any U_I_ uh uh cursor or whatever of your choice to give you a curl request like this. Or if you're building in Rust, you can ask it to give you like whatever Rust H_T_T_P_ library you're using, it'll create you just whatever their basics for like simple H_T_T_P_ fetching. There's no special magic here. You don't need an S_D_K_ to interact with this stuff. Um you have an H_T_T_P_ end point that should work.

[08:35] Christopher David: Uh your API token gets you access to that. Okay, so let's actually step through this and test it out. So I'm gonna go to openaddress.com and create a new user. Uh the other cool thing I'm looking for is uh we have a stats page on openaddress.com. I see

[08:48] Christopher David: Two of you have already signed up.

[08:51] Christopher David: When you create an account you'll see registered users go up. We have the number of agent instances. We also have the value transacted. And I've only tested this on my local machine. So like on it I'm gonna try to get like numbers on the board here. It should say uh you know the amount of Spark payments and Lightning payments transacted in the total. Um I will probably be in the judging criteria looking to see like whoever drives the most volume uh and makes these numbers go up the most, that will uh uh factor the judging for sure.

[09:16] Christopher David: For sure. Hopefully you're not just sending in payment between two agents infinitely, although that would be valuable too for stress testing purposes. Okay, let's sign up.

[09:23] Christopher David: Uh we'll call this Chris Hack Test Man. Email blah, blah, blah.

[09:28] Christopher David: Password.

[09:32] Christopher David: Alright, I'm in. I'm redirected to the docks. I'm gonna go to get a

[09:40] Christopher David: API key.

[09:48] Speaker C: Fuck, where did I put the A_P_I_ key part?

[10:01] Christopher David: I set up a redirect because the dashboard generally wasn't ready. Uh fuck. Oh here it is. Um it never mind never mind. Sorry. Bottom left, okay, this what you get for for building a U_I_ in three seconds. Uh bottom left you have settings. Please let me read the settings. Okay, thank God. Okay, here it is. Uh dashboard we'll just redirect to the docs because they don't have any actual dashboard there.

[10:17] Christopher David: Alright, we're good. We found it. We found it. Okay,

[10:19] Speaker D: Hmm.

[10:19] Christopher David: A_P_I_ keys. Uh okay, so here you're gonna name an A_P_I_ key. I'm gonna call it blah blah blah. Doesn't matter. Create A_P_I_ key. A_P_I_ key created, sorry there's no like nice copy button here, but I'm gonna copy this into a note.

[10:35] Speaker C: Yep.

[10:35] Christopher David: There's my A_P_I_ key. Feel free to impersonate me. I don't care.

[10:38] Christopher David: Um that's generally what it's gonna look like. You say I've copied my A_P_I_ key, it will not show up again. You have the basic information here.

[10:45] Christopher David: Um for just a basic test of your A_P_I_ key uh let's try this request here.

[10:51] Christopher David: I'm gonna copy that, I'm gonna drop my A_P_I_ key, make sure to include this front part with the thing there.

[10:58] Christopher David: And let's make an A_P_I_ request. I'm gonna go to my terminal, ignore all that stuff, let's try this.

[11:07] Christopher David: Okay, we have our user, I_D_ six, Chris Hack, test man, email, email verified, blah blah blah. Um

[11:13] Christopher David: Um and that just shows you the that's who you are logged in as. If someone else hits that endpoint they're not gonna get your information because they don't have your bearer token. Okay, so let's try some of these uh nice little things that uh open uh chat G_P_T_ gave us. So I'm gonna go do this one first. What'd it tell me to do? Create an agent. Let's create an agent. I'm gonna also draw my A_P_I_ key in here.

[11:31] Christopher David: And let's create an agent called my awesome live agent.

[11:35] Christopher David: And let's try that. And actually, let's take a look at the before and after of the stats page just to make sure that's updating correctly. So I've got agent instances five, paste, enter,

[11:45] Christopher David: misspelled, refresh. Alright, we have agent instance number six. Now let's see if we can get value transacted.

[11:52] Christopher David: Uh let's go back to here, create wallet. For now, you have to create a wallet um after you create the agent. I may consolidate that um but let's just do this.

[12:02] Christopher David: Let's create a wallet.

[12:05] Christopher David: And this is gonna be communicating to our server, which is throwing an error. Let's go see what it is. Uh let's see what we got here. Here's my where the service is hosted. Check out the logs here.

[12:23] Christopher David: A P Spark API running on port eighty eighty, okay, it's working.

[12:29] Speaker C: Uh but I got an error. So let's try this again on oh oh oh okay. If you see a massive mistake that I make, feel free to shout out. But here I didn't put in the Asian ID. So you're gonna take the Asian ID that you get back from the previous step, which in this case was six, and you're gonna drop it right there. Alright, you gotta tell it what you're creating the wallet for. So

[12:52] Speaker C: It's gonna take a couple seconds 'cause it is fail to create wallet services unavailable. Great, let's take a look. Okay, we crashed the app. Excellent.

[13:00] Speaker C: Let's see what happened.

[13:02] Speaker C: So yesterday I was doing this and it was working amazingly for two days in a row. And then I got an error like this with spark off end service. And uh the light spark service actually went down because their database was growing too fast and they had to scale it up. So like the service was just down for thirty minutes and like, I I don't know if they knew that it or I just flagged them something. I I don't know if they knew that already or not. But within thirty minutes I reported it and then they fixed it. Um

[13:28] Christopher David: Let's see if we can figure out what's going on here. Authentication error.

[13:31] Christopher David: Client error. Spark authentication error. Verified channel received R_S_T_ stream with server error.

[13:38] Christopher David: Verify challenge. Authentication failed.

[13:42] Christopher David: So the beautiful part about um one beautiful thing about Spark is that the um SDK does not require any API keys. Like if you use the Breeze SDK, you have to drop in a s an API key that you get from them. With Spark, it's all really just like you're using your bit thirty nine entropy, similar to Breeze for example. You are making a call to the the SDK the the SDK that they're using. Um and then that's just communicating to their servers.

[14:09] Christopher David: The problem is if their server is uh not uh accessible, which it looks like is the case here. Let's try it maybe one more time. Uh and then maybe I'll try again locally just to rule out that we don't have any problem there. So

[14:23] Christopher David: We got it working. Sometimes you just got to try it a second time. All of this stuff is bleeding edge stuff. I don't know why this succeeded and the previous one didn't. But we appreciate your help testing our beta API, which is sitting on top of a beta SDK. And if you didn't and if you didn't see this beta warning,

[14:40] Christopher David: let's zoom it in. The open agents API is currently in beta. Do not use it with live funds that you aren't willing to use. I'm going to fund this with like 10 sats.

[14:48] Christopher David: Spark does have like a reg test uh uh way of using it I I just haven't set that up at all, this is all main net. So um, you know, back in the early days of Lightning we called it hashtag reckless, like it's production but you'll probably lose your stuff, so uh hashtag reckless over on top of this. Okay, so when you successfully create an agent you'll get back agent I_D_ and the Spark address. So this is a thing that if you are interacting with somebody else's agent, if you give them the Spark address they should be able to pay your agent.

[15:16] Christopher David: agent.

[15:17] Christopher David: When you run the balance check command you should then see the balance update. There is one kind of unique thing about the spark infrastructure which is that like in order for the balance update to show you have to like reinitialize your wallet, which I think is done by a wallet balance check. There's been a couple of thing times where I've had to like kind of do an additional check or initialization. There's like something that we we may run into if your your balance doesn't immediately update. Um

[15:46] Speaker C: I've got like a longer explanation for that that A_I_ helped me understand that I'll probably post on the doc, but let's just try this right now. So we've got a our first wallet active uh we're gonna do that again and we're gonna fund this wallet. Let's see if it actually works. So I'm gonna create another agent and we'll call this one uh let's go back to here. Let's do create an agent. We'll call this one agent two.

[16:11] Speaker C: And I wanna try to get

[16:13] Christopher David: one agent funded and then paying the second agent. And then we'll call that uh call that the end. We'll call this my agent two.

[16:21] Christopher David: Let's create another agent, clear that out. My agent two created. I've got to go again, create uh wallet for this. Gonna go back over here, just m kind of save that. And then where's my wallet creation one here here.

[16:41] Christopher David: Agents, what was that ID seven?

[16:45] Christopher David: Bear blah blah blah. Copy. Paste.

[16:52] Christopher David: Okay, I now have two agents. There's their information.

[16:56] Christopher David: Now going to generate a lightning invoice on let's do it on agent six. So I'm gonna come over here, create a lightning invoice to fund it.

[17:05] Christopher David: Curl blah blah blah says agent six.

[17:10] Christopher David: I'm going to drop in my API key. Whenever you're using AI, you get really good at copy pasting. You get a lot of practice with it and there will come a time when we're not copy pasting a bunch of stuff in here. Okay, so let's do it for uh eight SATs

[17:27] Christopher David: and do that, see if that works.

[17:31] Christopher David: Please spark yeah, okay. We got it back. Here's our invoice.

[17:36] Speaker C: I'm gonna copy this and paste it to my Cash App, which is uh on my phone right now. Does anyone want to pay this invoice? Let me see.

[17:44] Speaker E: Okay.

[17:46] Speaker C: Can I drop it into the Slack?

[17:47] Speaker E: Yeah, just drop it in there.

[17:48] Speaker C: Yeah.

[17:50] Speaker C: Oh, where am I?

[17:53] Speaker C: Hip La La. Here's all of my stuff. Okay. Car.

[18:02] Christopher David: So in a second I will check the balance on that, and then while he's doing that let's get the transaction ready, or the A_P_I_ call ready to So that's the payment. Okay, so the um send one is for Spark, not pay, I don't care. I want to pay uh from agent six to agent seven. Pay agent six after funding the lightning invoice.

[18:31] Christopher David: So give me a what happened?

[18:33] Speaker F: It threw out.

[18:34] Christopher David: Oh, okay, let's just do a balance check.

[18:36] Christopher David: So give me a A_P_I_ call for uh the send of five sats.

[18:46] Speaker F: Any second.

[18:48] Christopher David: I'm gonna send five sats from agent six, which should have a balance of eight sats. So let's um first tell me how to check balance of agent six.

[18:59] Speaker C: Uh okay.

[19:06] Speaker C: Bearer, where's my key?

[19:18] Christopher David: Balance, eight sats. It worked, hooray. You'll also see token balances in there. Spark introduced a thing called LRC twenty tokens, I think intending initially to be used as stable coins. But uh shitcoins on Bitcoin may be coming soon too. I don't know how much we'll participate in that kind of thing. But uh these can support balances like stable coins as well. Uh let's see. So we have a eight agent six with eight sats. We have agent seven with zero sats. We just confirmed that it actually has

[19:44] Christopher David: uh zero sats by running that same command again with agent seven in there okay

[19:54] Christopher David: let's make a spark payment from six to seven and let's see if we end up with the same amount

[19:59] Christopher David: stats or if there's a fee that we don't know about. Uh let's see. Curl blah blah blah. So pay, send

[20:13] Christopher David: from

[20:15] Christopher David: wallet six to recipient agent seven, five cents.

[20:22] Christopher David: Fingers crossed to the demo gods.

[20:36] Christopher David: Perfect, okay.

[20:37] Christopher David: So um

[20:39] Christopher David: the transaction looks like it went through. The status of transfer status sender two key tweaked,

[20:44] Speaker B: Is that

[20:44] Christopher David: you can Google that, but that's the thing I was talking about earlier where it's like you need to you might need to reinitialise the

[20:52] Christopher David: l l let's just let's just see what happens if we check the balance of six and seven. So six

[20:58] Christopher David: balance of stats three, that's what we expect to see.

[21:01] Christopher David: And seven,

[21:03] Christopher David: five.

[21:06] Christopher David: Okay,

[21:07] Christopher David: it worked.

[21:07] Christopher David: I guess the checking of the wallet, like, initializes it.

[21:13] Christopher David: Okay, so we sent a FiveSat transaction from agent one to agent two. Um, you if you had the spark address of any of these, you'd be able to send sats over spark to any of these um and if you're a you're also able to generate and pay lightning invoices from these. That should be enough for like doing basic um payments related things. The the main objective here is like make it as easy for someone to add lightning payments to any agent.

[21:41] Christopher David: It's not even just any agent because you could be doing this with like like there's nothing even specifically agentic about what we implemented here Just like in a series of API endpoints that can interact easily with lightning that you don't have to care about liquidity or channels or any of that kind of thing There's no KYC to this you sign up with a fake email address and password and like you can hit all this stuff And it should work.

[22:01] Christopher David: Oh, let's check out to see if we are stats page updated whole fingers crossed that worked now something's wrong with our

[22:08] Christopher David: stats reporting, uh for the tr tran value transact. We'll figure that out later. Um

[22:12] Speaker C: Mm.

[22:14] Christopher David: Well we saw on the spring that we said that worked. Okay, any questions from anybody?

[22:19] Speaker D: User interface for this website, is that not is that code available anywhere or no?

[22:24] Christopher David: No.

[22:24] Speaker D: Okay.

[22:31] Christopher David: So I'll be floating around.

[22:32] Christopher David: Any questions anybody has for these kind of things, again I'd like to see hopefully like some amount of uh volume of transactions, um and then maybe like some cool ways that these agents can interact with existing lightning services. If you say like oh here's how we figured out how to make this pay uh a zap-rite store checkout, something like that. Uh or if you had got together with some other Hackathon participant and um

[22:56] Christopher David: Uh you know, did something cool with each other. Can I split the winnings if there's like two projects that do something cool?

[23:02] Speaker D: Yeah, you guys, so yeah, so let's just send you right there, you wanna go for a quick? Well, and then we'll go over the rules and everything.

[23:07] Christopher David: Cool.

[23:07] Speaker E: You could ask a question.

[23:07] Christopher David: Yeah, yeah.

[23:08] Speaker D: Yeah, you can go over them.

[23:09] Speaker E: Um you had mentioned at some point that open agents has uh integration with GitHub or is like it knows GitHub well and you don't have to deal

[23:18] Christopher David: Yeah, so our previous, if you go down to the openagents.com we have an interface Oops.

[23:26] Christopher David: A chat UI that we've moved to v4.openagents.com. If you get if you want to chat with AI and and and this might be helpful for like vibe coding type things, um I I wouldn't recommend this right now, like I I I personally I used to use this mostly as my daily driver, but right now like Cloud code is just better. Um but anyway.

[23:47] Christopher David: We will be tying so so just a little bit of li let me end on this note, a little bit of where we're going with this.

[23:53] Christopher David: Uh so this payment thing we're blog we're announcing. Okay so um

[23:59] Christopher David: We want to be doing Bitcoin revenue sharing, where if you let's just say that you refer someone who does a lot of v volume, we want to give you a little piece of that. We want to be um creating kind of a monetisation layer for M_C_P_ so one thing that M_C_P_ is great at is like this idea of the possibility for discovering services that your A_I_s can use, but there's no kind of built-in payments or pricing with that. So it's hard to discover like knowing what pe what is actually good like I wanna know who's actually spending

[24:26] Christopher David: Compute on like top NC M_C_P_s. Like that should be like something I could just pull up and see what what the Sass flow is going to. Um the objective here,

[24:35] Speaker D: Uh-huh.

[24:35] Christopher David: even though we're just starting by kind of like sitting on top of the Spark S_D_K_ uh we wanna add support to everything else that's relevant in anything relevant to Bitcoin-based finance for agents so stable coins including Tether so like to my knowledge Spark is not doing anything with Tether, they've got their own like stable coin partnership with something that was

[24:52] Christopher David: thing that has like one percent of the volume but um i want to add taproot asset support to this that shouldn't be too difficult and so have you know agents able to also transact with tether uh we're going to be combining this with a like a self-custodial web wallet so we're going to keep this kind of like experimental bleeding edge stuff for the ai agents um but i want to be able to have a dashboard in here where you can kind of sweep your balances to your agent from your agents to your personal wallet the personal wallet will be using uh will be on breeze they just released their um

[25:19] Christopher David: uh web-based sdk using wasom. They took their sdk and made it available to web pages, so you can now do breeze uh you know built into a website. Uh we may offer some select lrc to twenty tokens if we think that are cool. Um no reason not to add try me an e-cash, got to do cashew and have these also speak l four two. Basically any kind of bitcoin-based protocol, agents should be able to speak it. I don't know which of these is gonna be like more prominent or whatever, but we would just wanna make it easy for developers to be able to like

[25:45] Christopher David: that'll like have one API call and then just have all this accessible to them. So we'll be working on that over the next month or two. I really really really appreciate any feedback anyone has you've run into bugs please come tell me um and best of luck to you. Thank you.