[00:15] (15.04s)
for a show of hands.
[00:18] (18.56s)
How many people in this audience know
[00:21] (21.12s)
who Circle is? What we do? Um, just just
[00:24] (24.16s)
trying to gauge. Okay. Okay. Um, do you
[00:28] (28.32s)
know anything about our developer
[00:29] (29.68s)
tooling? Gotcha. Gotcha. So, nobody.
[00:33] (33.76s)
Okay. So, this is good. All right.
[00:37] (37.20s)
Um, first, you know, I just want to
[00:39] (39.36s)
introduce myself. Uh, my name is Corey
[00:41] (41.04s)
Cooper. I lead Devril at Circle. Uh,
[00:43] (43.68s)
this talk is about the intersection of
[00:46] (46.40s)
some exploratory work we've been doing
[00:48] (48.24s)
internally
[00:50] (50.40s)
between AI and programmable money. And
[00:53] (53.92s)
um you know one of the things we noticed
[00:56] (56.96s)
a trend in with USDC uh when Circle
[01:00] (60.32s)
launched its digital dollar technology
[01:02] (62.64s)
is that um it was an order of a
[01:04] (64.80s)
magnitude better at doing ex escrow than
[01:07] (67.92s)
traditional payment rails. And so, uh,
[01:11] (71.76s)
combining USDC with AI gives you a way
[01:15] (75.28s)
to do some type of verification of, uh,
[01:18] (78.24s)
workflows that are, uh, happening that
[01:20] (80.64s)
need to be met in order for escrow
[01:22] (82.56s)
agreement to be, uh, honored. And then
[01:25] (85.28s)
you get instant settlement with, uh, a
[01:28] (88.32s)
stable coin that can settle um, faster
[01:31] (91.60s)
than T plus2 around the world.
[01:35] (95.60s)
So, in this presentation, what we'll do
[01:37] (97.52s)
is I'll give you a background on Circle.
[01:39] (99.20s)
I'll give you an overview of our
[01:40] (100.88s)
developer tooling. Then we'll jump into
[01:44] (104.08s)
our smart contract um that powers USDC,
[01:47] (107.44s)
the technology that makes it a
[01:49] (109.28s)
programmable dollar and uh and gives it
[01:51] (111.92s)
features and attributes that you can't
[01:53] (113.60s)
do with uh a digital representation of a
[01:56] (116.96s)
dollar in traditional u payment rails.
[01:59] (119.92s)
And then we'll end off with giving a
[02:02] (122.56s)
live demo of our escrow agent
[02:05] (125.68s)
application that we open sourced
[02:07] (127.44s)
recently. and um allow you all to set up
[02:10] (130.72s)
this in your environment if you want to
[02:12] (132.56s)
locally. I can walk you through doing
[02:14] (134.08s)
that today or we can just do a Q&A. You
[02:16] (136.96s)
can ask some questions about um you know
[02:19] (139.28s)
anything about you know our dev tooling
[02:21] (141.20s)
and and where we see this marriage
[02:23] (143.12s)
between agents and USDC going.
[02:29] (149.28s)
So, just to give you a quick um
[02:31] (151.84s)
background about Circle, um it's a
[02:34] (154.48s)
fintech company um that issues stable
[02:37] (157.36s)
coins. Um we were established in 2013.
[02:40] (160.56s)
Um and some of our our backers are the
[02:44] (164.00s)
pillars in the financial services
[02:45] (165.60s)
industry like Black Rockck and Fidelity.
[02:48] (168.56s)
The reason for that is because we've
[02:50] (170.96s)
we've done uh a really good job of
[02:53] (173.92s)
providing trust and transparency that
[02:55] (175.92s)
the digital tokenized version of the US
[03:00] (180.16s)
dollar or the euro that we deploy on
[03:03] (183.76s)
different blockchain networks is backed
[03:06] (186.00s)
one to one with fiat uh and short-term
[03:09] (189.52s)
treasuries in a bank account. So it's
[03:12] (192.24s)
fully reserved 100%. We also have led
[03:15] (195.76s)
the charge in regulation around this
[03:18] (198.96s)
industry and really helped um regulators
[03:23] (203.28s)
around the world think about this as a
[03:25] (205.92s)
ground breaking technology for payments
[03:28] (208.72s)
and um as you see there's some things
[03:31] (211.04s)
that are happening in the US and across
[03:33] (213.52s)
the world where um laws are being passed
[03:36] (216.56s)
to regulate stable coins which we're
[03:38] (218.64s)
happy about because it's going to give
[03:40] (220.56s)
businesses and individuals opportunity
[03:42] (222.32s)
to take advantage of this technology.
[03:45] (225.28s)
And so,
[03:47] (227.04s)
um, another note is, um, you know, since
[03:49] (229.76s)
inception, we've been able to, uh, be
[03:52] (232.56s)
responsible for settling over 26
[03:54] (234.56s)
trillion of of transactions on, um,
[03:58] (238.96s)
roughly we're on roughly 20 different
[04:00] (240.96s)
blockchains and going right now. But um
[04:03] (243.60s)
that that's a huge accomplishment for uh
[04:07] (247.12s)
the amount of engineering resources, the
[04:09] (249.12s)
product resources, marketing resources
[04:11] (251.36s)
that the company has poured into to you
[04:14] (254.48s)
know allowing businesses and individuals
[04:16] (256.56s)
to be able to take advantage of this
[04:18] (258.00s)
technology and build on top of it as a
[04:20] (260.32s)
payment rail.
[04:24] (264.00s)
So, here is a um a chart or not really a
[04:27] (267.52s)
chart, it's an overview slide, a visual
[04:30] (270.32s)
of the lay of the land of what we offer
[04:32] (272.96s)
as a company.
[04:35] (275.12s)
Like I mentioned earlier, um you know,
[04:37] (277.84s)
we issue USDC and EURC.
[04:41] (281.20s)
Um, we recently acquired a company
[04:43] (283.44s)
called Hashnote where we now have a
[04:45] (285.60s)
tokenized version of a money market
[04:47] (287.52s)
fund. Um, which is going to give us the
[04:50] (290.16s)
ability to do um, something with money
[04:52] (292.24s)
markets that were never possible before.
[04:54] (294.40s)
Uh, to be able to liquidate out of a
[04:56] (296.48s)
money market into USDC 24/7, 365 days a
[05:00] (300.40s)
week. Um and then we have our liquidity
[05:02] (302.96s)
services for uh payment service
[05:06] (306.00s)
providers, financial institutions
[05:08] (308.64s)
uh where we enable them to be able to
[05:10] (310.64s)
mint and redeem USDC um to a very secure
[05:14] (314.72s)
enterprisegrade vault wallet on chain
[05:17] (317.44s)
for uh performing different types of use
[05:20] (320.24s)
cases that relate to payments
[05:23] (323.12s)
um dollar access as well as uh capital
[05:27] (327.28s)
markets.
[05:29] (329.12s)
And on the far right
[05:31] (331.44s)
we have our developer services. And this
[05:35] (335.36s)
portion of um of what we offer is what
[05:39] (339.44s)
will be wrapped into what we will
[05:41] (341.04s)
demonstrate today with the sample app
[05:42] (342.88s)
that I'll demo uh where comprises of
[05:45] (345.92s)
wallets. So well a developer can embed
[05:48] (348.96s)
wallets in their application
[05:51] (351.84s)
programmatically.
[05:53] (353.44s)
We also have uh circle contracts. So
[05:56] (356.88s)
that's a smart contract platform that
[05:58] (358.80s)
enables you to deploy uh contracts
[06:01] (361.84s)
programmatically and read to those
[06:04] (364.24s)
contracts as well as write.
[06:08] (368.08s)
And then uh under that we have our
[06:10] (370.00s)
circle pay master and CCTP. And if
[06:13] (373.84s)
anybody knows anything about
[06:16] (376.80s)
transacting on public blockchain
[06:18] (378.48s)
networks, there is something called gas
[06:20] (380.72s)
fees. And so what we've done is we've
[06:23] (383.52s)
enabled um end users to be able to pay
[06:26] (386.96s)
for gas fees within u USDC. So from the
[06:30] (390.48s)
USDC balance. So it actually feels like
[06:33] (393.04s)
a traditional payment transaction as
[06:35] (395.52s)
opposed to having some native token that
[06:37] (397.92s)
you always have to have in your wallet
[06:39] (399.36s)
to be able to transact. And then since
[06:42] (402.48s)
we're on all these blockchain networks,
[06:44] (404.16s)
there is a lot of fragmentation that we
[06:45] (405.76s)
were trying to unify. And the way we
[06:48] (408.08s)
unify that is with our crosschain
[06:49] (409.84s)
transfer protocol that allows for you to
[06:52] (412.80s)
move USDC between different blockchain
[06:55] (415.68s)
networks permissionlessly. And you as a
[06:58] (418.72s)
developer can build very seamless
[07:01] (421.12s)
multi-chain experiences around this this
[07:03] (423.28s)
protocol um so that you don't have
[07:06] (426.64s)
fragmentation where someone is on one
[07:09] (429.04s)
chain and they can't transact on another
[07:10] (430.80s)
chain. So you can do crosschain
[07:12] (432.08s)
transactions uh and things like that.
[07:16] (436.16s)
And at the bottom layer are uh all the
[07:19] (439.84s)
blockchains that we natively have USDC
[07:23] (443.52s)
issued on. Uh this this list is getting
[07:26] (446.72s)
longer. Um so but you know we are we are
[07:30] (450.48s)
in a multi-chain world where we want
[07:33] (453.44s)
USDC to be the uh premier digital dollar
[07:37] (457.28s)
and so we are building all types of
[07:39] (459.12s)
onchain uh utility around USDC as well
[07:42] (462.72s)
as ERC to make uh this um you know
[07:47] (467.28s)
support for multiple blockchains more
[07:49] (469.20s)
unified. So there will be some other
[07:51] (471.36s)
innovations that we're going to release
[07:52] (472.72s)
in the next couple of weeks and months
[07:55] (475.84s)
um that advance the unification of
[07:58] (478.48s)
balances across multiple blockchain
[08:00] (480.80s)
networks with our um stable coin
[08:02] (482.96s)
technology.
[08:06] (486.64s)
So let's let's dive into USDC um and and
[08:10] (490.08s)
just really talk about the attributes
[08:11] (491.68s)
that are really important to a
[08:13] (493.28s)
developer. And so um one of the things
[08:16] (496.48s)
is you know it is a dollar that is
[08:19] (499.84s)
internet native. And so what that means
[08:21] (501.84s)
is the ledger of that dollar is built
[08:24] (504.56s)
into internet technology which is
[08:27] (507.04s)
blockchain networks and smart contracts.
[08:29] (509.20s)
And so it enhances the programmability,
[08:32] (512.80s)
the transferability
[08:34] (514.80s)
um to enable money to move in seconds
[08:38] (518.08s)
globally. And so it's not constricted to
[08:41] (521.28s)
some of the uh friction points we have
[08:43] (523.76s)
in legacy payment rails.
[08:48] (528.48s)
The other thing is because it's uh
[08:52] (532.32s)
native to the internet, it's it's it has
[08:55] (535.12s)
no borders. Um so it works like email or
[08:58] (538.40s)
or text where you know you can send text
[09:01] (541.20s)
or email around the world. We want to
[09:04] (544.00s)
make money to be that seamless to be
[09:06] (546.24s)
able to transact with. And so um because
[09:09] (549.44s)
of it being issued on public blockchain
[09:12] (552.64s)
networks, it gives it the borderless uh
[09:15] (555.68s)
freedom to be able to transact globally.
[09:20] (560.08s)
And then last, when you have a network
[09:23] (563.12s)
that is permissionless and public and
[09:25] (565.68s)
open, uh it makes it very easy for other
[09:29] (569.36s)
companies, individuals to plug into this
[09:32] (572.96s)
actual network of money um and transact
[09:36] (576.80s)
with it. And so um it it's scaling very
[09:40] (580.32s)
fast globally because of the openness of
[09:43] (583.12s)
anybody being able to build on top of
[09:45] (585.60s)
this protocol for sending and receiving
[09:48] (588.80s)
and storing uh value.
[09:52] (592.32s)
And so how does this work? you know, uh,
[09:55] (595.44s)
how it works is how USDC gets issued in
[09:57] (597.92s)
the ecosystem is a business gets
[10:02] (602.00s)
approved by Circle to set up a business
[10:04] (604.96s)
account and then they connect their bank
[10:08] (608.40s)
account to our Circle Mint platform and
[10:13] (613.60s)
they wire their fiat to our reserve bank
[10:17] (617.44s)
account. After that that fiat settles as
[10:21] (621.68s)
USD in our bank account, then we mint
[10:24] (624.88s)
the corresponding amount of USDC
[10:28] (628.16s)
and credit their circle mint account.
[10:30] (630.80s)
And so that is how USDC gets issued in
[10:34] (634.48s)
the ecosystem. Now the reverse process
[10:37] (637.12s)
happens when the business wants to get
[10:39] (639.12s)
out of USDC. they can redeem uh and
[10:42] (642.24s)
there's a onetoone with um every USDC
[10:47] (647.28s)
minted to a US dollar. So um when they
[10:50] (650.72s)
want to get out um they get that
[10:52] (652.64s)
onetoone parody and so that is the trust
[10:55] (655.76s)
and transparency that we provide to our
[10:58] (658.08s)
customers. Uh we also um do a little bit
[11:01] (661.76s)
of extra things and you can go on our
[11:04] (664.00s)
website where we have a USDC
[11:05] (665.60s)
transparency page where you can go and
[11:07] (667.52s)
see our monthly addestations. Um and we
[11:10] (670.64s)
have various auditors um that are
[11:13] (673.04s)
independent of the company that continue
[11:15] (675.04s)
to audit and make sure that we are fully
[11:18] (678.40s)
reserved and we you know make sure we
[11:20] (680.88s)
ensure the trust and transparency around
[11:24] (684.48s)
the actual issuance of a digital repres
[11:27] (687.20s)
representation of the dollar on uh
[11:32] (692.64s)
So now we're going to jump into the USDC
[11:36] (696.40s)
smart contract and really dive into like
[11:39] (699.12s)
what makes this programmable, how does
[11:41] (701.28s)
it work.
[11:44] (704.72s)
So one thing is uh we have um you know
[11:48] (708.16s)
very strict implementation requirements
[11:50] (710.24s)
before we uh deploy USDC on a different
[11:53] (713.52s)
blockchain network. And so, um, here are
[11:57] (717.12s)
the things that we want to make sure
[11:58] (718.80s)
that we can incorporate in the token
[12:01] (721.28s)
contract before deploying it on a
[12:03] (723.20s)
blockchain network just to make sure we
[12:05] (725.68s)
have standardization across the board.
[12:09] (729.12s)
um you know as we um expand to different
[12:11] (731.60s)
blockchain ecosystems, but also too to
[12:14] (734.32s)
make sure that there are safeties uh
[12:17] (737.84s)
provisions that we have built into this
[12:20] (740.08s)
actual smart contract for businesses and
[12:23] (743.04s)
individuals to be able to trust and use
[12:25] (745.76s)
our technology as a protocol for money
[12:29] (749.04s)
movement globally.
[12:31] (751.36s)
And so um here are some of the things I
[12:34] (754.56s)
I'll jump into and and and provide a
[12:36] (756.80s)
little bit more clarity around the
[12:38] (758.16s)
implementation requirements. But um the
[12:40] (760.64s)
first is um allow list and block list.
[12:43] (763.36s)
And so this enables us to basically prot
[12:46] (766.88s)
protect you know um people who use our
[12:49] (769.52s)
token contract from bad actors. And so
[12:52] (772.08s)
if we know someone's on a sanction list
[12:54] (774.96s)
um you know and and they're a malicious
[12:57] (777.44s)
actor, we have the ability to actually
[13:00] (780.56s)
um stop them from transacting and
[13:02] (782.96s)
protect other users from transacting
[13:05] (785.36s)
with that actual user. And so um it's
[13:08] (788.40s)
built in for for safety for businesses.
[13:13] (793.20s)
And then we have um spend on behalf. And
[13:15] (795.84s)
so that's a feature where you know say
[13:18] (798.32s)
if you're a business and you wanted to
[13:20] (800.24s)
create a financial workflow where you
[13:22] (802.48s)
wanted to enable um you know somebody to
[13:26] (806.72s)
spend uh a certain amount of money from
[13:28] (808.88s)
a wallet balance uh and and give them a
[13:31] (811.60s)
cap on that on a daily basis. Um there
[13:34] (814.56s)
is functionality built into it where you
[13:37] (817.12s)
can delegate for uh a user to be able to
[13:40] (820.32s)
spend a certain amount of money from a
[13:42] (822.64s)
actual wallet balance using USDC. Yeah.
[13:45] (825.76s)
Like is a scenario with that like a
[13:47] (827.68s)
corporate um you know corporate account
[13:50] (830.88s)
or something like corporate business
[13:52] (832.72s)
card. So say if you have u some some
[13:55] (835.60s)
virtual debit cards that you're issuing
[13:57] (837.92s)
to your actual uh employees and the
[14:01] (841.12s)
actual debit card is powered by a USDC
[14:04] (844.32s)
balance in a wallet. You could design
[14:06] (846.96s)
basically a workflow where you could put
[14:09] (849.44s)
thresholds on how much they could spend
[14:11] (851.12s)
from that corporate card. Would you
[14:12] (852.96s)
realistically be able to run that to
[14:14] (854.72s)
like thousands, tens of thousands,
[14:16] (856.88s)
hundreds of thousands, or would that not
[14:18] (858.32s)
be a proper use case? No, no, you could
[14:20] (860.56s)
scale it up. Yeah. Oops, sorry. You you
[14:23] (863.84s)
could you could definitely scale that
[14:25] (865.20s)
that delegation of spending um for that
[14:28] (868.88s)
fat wallet address with a virtual debit
[14:31] (871.36s)
card uh to tens of thousands. Yeah.
[14:37] (877.52s)
Another is is mentor configuration. And
[14:39] (879.76s)
so um you know we we have the ability to
[14:44] (884.08s)
uh add um you know other uh entities to
[14:47] (887.52s)
be able to uh mint from our token
[14:50] (890.16s)
contract. This is something that we
[14:52] (892.16s)
haven't done, but there could be a
[14:53] (893.84s)
future where we could partner with
[14:55] (895.52s)
financial institutions and they have a
[14:58] (898.32s)
balance that they can mint from from the
[15:00] (900.24s)
actual token contract.
[15:06] (906.24s)
And then uh multi-IG transactions. Um
[15:09] (909.36s)
this is this is for you know like if
[15:11] (911.12s)
you're building some type of workflow
[15:12] (912.96s)
where maybe you require the CEO, CFO and
[15:16] (916.40s)
CFO to actually sign off on transactions
[15:19] (919.20s)
that are above a certain threshold. you
[15:21] (921.44s)
can design these type of um
[15:23] (923.44s)
transactional experiences to protect
[15:25] (925.60s)
from um you know a wallet being drained
[15:29] (929.20s)
um based off of like one person having
[15:31] (931.60s)
total control of you know the the
[15:33] (933.92s)
transaction ability of that wallet
[15:38] (938.40s)
coal storage support um a use case for
[15:42] (942.32s)
this is where maybe you know that um
[15:45] (945.76s)
you're running payroll uh on a monthly
[15:48] (948.48s)
basis using USDC for your employees. You
[15:52] (952.88s)
know the date and time that you're going
[15:54] (954.40s)
to be sending money out. You know the
[15:56] (956.08s)
amount. Um you have the ability to to
[15:58] (958.96s)
put those transactions in a ready state
[16:01] (961.60s)
that are offline. And so when that date
[16:04] (964.24s)
and time comes, it's ready. The
[16:06] (966.16s)
transaction object has already been
[16:07] (967.68s)
approved and signed and then you can
[16:09] (969.44s)
just broadcast that to the actual uh
[16:11] (971.92s)
blockchain network to send that off. So
[16:14] (974.08s)
it allows you to kind of prepare
[16:15] (975.68s)
transactions offline. Is that proof of
[16:18] (978.48s)
funds? um uh transactions so that it's
[16:22] (982.32s)
ensure that the money is there when the
[16:24] (984.24s)
time comes. It it could be designed for
[16:26] (986.72s)
that. Uh but it's more it's more of you
[16:30] (990.32s)
have a cadence of transactions that you
[16:33] (993.20s)
know are going to happen on you know a
[16:35] (995.20s)
bi-weekly or monthly basis and you want
[16:37] (997.76s)
to make sure that that transaction is
[16:40] (1000.16s)
already ready to go uh and in a state
[16:42] (1002.72s)
where it's already been signed and
[16:44] (1004.24s)
approved for and then it can just be
[16:46] (1006.24s)
broadcasted at a late later date. So it
[16:48] (1008.96s)
doesn't necessarily prevent it from
[16:50] (1010.32s)
bouncing. Uh no no. Yeah.
[16:56] (1016.96s)
And then since this is a new concept of
[16:59] (1019.04s)
money um and we're constantly, you know,
[17:02] (1022.64s)
thinking about ways of how we can
[17:04] (1024.72s)
enhance the actual protocol of money
[17:07] (1027.52s)
movement, there are times where we need
[17:10] (1030.72s)
to pause the contract for upgrading it.
[17:13] (1033.60s)
And so this hasn't been done much, but
[17:16] (1036.00s)
the most recent one was uh um about two
[17:20] (1040.16s)
years ago, a year and a half to two
[17:22] (1042.08s)
years ago. And um you know it's USDC
[17:24] (1044.72s)
version 2.2. And the main thing that we
[17:27] (1047.68s)
did was we um made it more gas
[17:29] (1049.76s)
efficient. And so um knowing that we
[17:32] (1052.56s)
want to make this technology scalable,
[17:34] (1054.96s)
we want to make sure that gas fees never
[17:36] (1056.72s)
become an issue. And so we were able to
[17:39] (1059.12s)
design different uh functionality in the
[17:41] (1061.52s)
token contract to optimize for uh better
[17:44] (1064.48s)
gas performance across chains.
[17:49] (1069.84s)
And so now I'll jump into the um
[17:52] (1072.88s)
contract functions of USDC.
[17:55] (1075.92s)
And so these are uh basically the
[17:58] (1078.88s)
functions the core functions that a
[18:01] (1081.76s)
developer would plug into when um
[18:04] (1084.40s)
commonly transacting with USDC. And you
[18:06] (1086.88s)
have uh balance of total supply,
[18:10] (1090.08s)
allowance, transfer, transfer from, and
[18:13] (1093.20s)
approve. And so these are these are um
[18:16] (1096.72s)
you know functions that are built into
[18:18] (1098.56s)
the actual smart contract that powers
[18:20] (1100.56s)
USDC uh that you'll see actually later
[18:23] (1103.28s)
on when I do the demo that we'll be
[18:25] (1105.60s)
using to actually uh perform the actual
[18:28] (1108.32s)
escrow transaction. And so um one of the
[18:31] (1111.84s)
the the most commonly used uh functions
[18:34] (1114.88s)
from this actual contract list is uh
[18:37] (1117.52s)
transfer from. And so uh in that
[18:39] (1119.68s)
argument you see you put the uh from
[18:41] (1121.76s)
address and the to address and then
[18:43] (1123.52s)
amount and you pass that um and then
[18:47] (1127.04s)
that gets broadcasted to the actual
[18:49] (1129.44s)
block um blockchain network to be able
[18:51] (1131.76s)
to actually send that transaction and
[18:53] (1133.92s)
you're you're telling it to send
[18:55] (1135.76s)
basically money from this account to
[18:58] (1138.08s)
that account. and then the amount of
[19:00] (1140.24s)
USDC that you want to send. And so that
[19:03] (1143.12s)
that's the programmability that you get
[19:05] (1145.36s)
with USDC that that is not built into
[19:08] (1148.72s)
the digital representation of um fiat uh
[19:13] (1153.28s)
in a database. Um and so that's where
[19:16] (1156.32s)
the magic allows you as developers in
[19:18] (1158.88s)
the room to create these very innovative
[19:20] (1160.88s)
experiences that were not available to
[19:24] (1164.80s)
And so, um, you know, USDC is, you know,
[19:28] (1168.88s)
it's kind of funny, but, uh, it's
[19:31] (1171.60s)
designed for agents. Uh, basically how
[19:33] (1173.84s)
we've seen agents kind of proliferate
[19:35] (1175.68s)
over the last year or so, uh, it seems
[19:37] (1177.92s)
like it's just the perfect currency for
[19:40] (1180.24s)
an agent to use to transact. And so, um,
[19:44] (1184.16s)
some of the reasons why is, you know,
[19:46] (1186.48s)
one, you get near instant, uh,
[19:48] (1188.24s)
settlement, uh, and built-in
[19:49] (1189.92s)
verification of transactions. And so
[19:51] (1191.68s)
when an agent is transacting, it's not a
[19:53] (1193.68s)
human. Uh and so one thing um you know
[19:57] (1197.60s)
you want to do is you want to allow the
[19:59] (1199.36s)
agent to be able to to transact and
[20:02] (1202.00s)
those agents if they're doing agentto
[20:03] (1203.52s)
agent payments, they want near instant
[20:06] (1206.16s)
settlement because u these are robots
[20:09] (1209.36s)
transacting. Uh, another thing is you
[20:12] (1212.00s)
don't want robots to have to deal with
[20:13] (1213.76s)
chargebacks. And so that could be a
[20:16] (1216.72s)
nightmare because when agents start
[20:18] (1218.80s)
transacting with each other, money is
[20:20] (1220.48s)
going to flow very fast. And so a
[20:23] (1223.04s)
chargeback could be a catastrophic uh
[20:25] (1225.68s)
risk to running agent-to-ag payments,
[20:29] (1229.12s)
you know, on reversible rails.
[20:32] (1232.48s)
The other thing is um you know agents
[20:36] (1236.96s)
are are always on you know and so they
[20:39] (1239.68s)
need a payment rail that's always on uh
[20:42] (1242.24s)
24/7 no banking hours. And so um you
[20:46] (1246.16s)
know the the great thing about you know
[20:48] (1248.24s)
this public blockchain infrastructure is
[20:50] (1250.32s)
you have this compute that's always on
[20:52] (1252.56s)
that enables settlement to happen 247
[20:55] (1255.60s)
globally with no banking hours. And all
[20:58] (1258.16s)
of these transactions are verifiable um
[21:01] (1261.04s)
through private and public key um
[21:03] (1263.36s)
technology. And so the cryptography um
[21:06] (1266.40s)
and and the actual openness of these
[21:09] (1269.20s)
actual ecosystems make it a perfect um
[21:12] (1272.48s)
payment rail for for agents to transact
[21:14] (1274.96s)
because um there's there's no downtime.
[21:18] (1278.80s)
Oops. Let's go back. And then the last
[21:21] (1281.76s)
thing is I'll go back to the slide where
[21:24] (1284.88s)
I was showing the actual contract
[21:26] (1286.72s)
functions. It's the programmability. Um,
[21:29] (1289.36s)
you know, agents are going to need to be
[21:31] (1291.84s)
able to have a lot of programmability
[21:34] (1294.40s)
because there are going to be
[21:35] (1295.52s)
transactions where they'll need to be
[21:37] (1297.12s)
able to um, you know, perform some sort
[21:40] (1300.16s)
sort of logic uh, that they need to pass
[21:43] (1303.28s)
before they can actually make that
[21:45] (1305.36s)
transaction. And so that logic can
[21:47] (1307.04s)
actually be built into composable smart
[21:49] (1309.20s)
contracts uh that we'll show in this uh
[21:52] (1312.40s)
demo of of how like this is great for
[21:55] (1315.28s)
escrow because um you know you have the
[21:57] (1317.92s)
ability to perform value transfer with
[22:00] (1320.96s)
all this conditional conditional logic
[22:02] (1322.88s)
that you can actually program in and the
[22:04] (1324.80s)
agent can actually interact with that
[22:06] (1326.64s)
logic to be able to perform those
[22:08] (1328.16s)
transactions. So, uh, very powerful
[22:10] (1330.72s)
technology here.
[22:13] (1333.04s)
And so, um, now I'll jump into the
[22:15] (1335.60s)
sample app. And so, first I'll run
[22:17] (1337.60s)
through kind of the architecture, what
[22:19] (1339.84s)
we used, and how it works. And then
[22:23] (1343.12s)
we'll jump into a demo of it, and then
[22:26] (1346.32s)
um, everybody can have time to actually
[22:28] (1348.24s)
set it up in their own environment, and
[22:29] (1349.76s)
I can walk around and help you out if
[22:31] (1351.68s)
you have any issues. So
[22:35] (1355.52s)
the core building blocks from a dev
[22:37] (1357.92s)
tooling st stand standpoint of what we
[22:39] (1359.76s)
used to to build this actual escrow flow
[22:44] (1364.48s)
is uh we use circle wallets and so that
[22:47] (1367.20s)
enabled us to actually provision wallets
[22:49] (1369.44s)
for the agent the u and the two parties
[22:53] (1373.12s)
involved in the actual escrow process.
[22:56] (1376.00s)
Um and then also too we use circle
[22:58] (1378.40s)
contracts. So we were able to um
[23:01] (1381.60s)
actually we wrote a solidity contract um
[23:04] (1384.80s)
and then we uh deployed that using the
[23:08] (1388.00s)
circle contracts API. So um it was a
[23:11] (1391.20s)
repeatable um process of us deploying
[23:14] (1394.00s)
contracts for each actual um group of
[23:18] (1398.00s)
parties that are transacting. And so uh
[23:20] (1400.80s)
that API allowed for us to take you know
[23:23] (1403.20s)
this this template of a escrow contract
[23:25] (1405.44s)
in solidity and repeatedly deploy it and
[23:28] (1408.24s)
use it for different parties involved
[23:30] (1410.80s)
transacting amongst each other. And then
[23:33] (1413.92s)
lastly, USDC um being able to embed the
[23:39] (1419.76s)
uh USDC stable coin in the actual smart
[23:42] (1422.72s)
contract gave us the ability to um
[23:45] (1425.84s)
design basically um a smart contract
[23:49] (1429.76s)
that is running off of dollars um and
[23:53] (1433.52s)
interoperable with the actual fiat world
[23:56] (1436.64s)
as well because uh kind of the likely
[23:59] (1439.52s)
process of of some of this will be uh
[24:02] (1442.16s)
there's a onramping experience from fiat
[24:04] (1444.32s)
to USDC and then there's a off-ramping
[24:06] (1446.48s)
experience where the beneficiary wants
[24:08] (1448.00s)
to go back to actual fiat and using the
[24:11] (1451.36s)
actual smart contract in USDC gives both
[24:14] (1454.80s)
parties the trust that they have a
[24:16] (1456.96s)
tokenized version of the dollar that
[24:18] (1458.56s)
they know they can get in and out of
[24:20] (1460.16s)
anytime one to one.
[24:23] (1463.44s)
So here's kind of how the onboarding
[24:26] (1466.48s)
flow works. As you can see from this uh
[24:29] (1469.76s)
this design, you have a client which is
[24:32] (1472.56s)
the business and the freelancer and they
[24:34] (1474.56s)
both come to a platform and create an
[24:37] (1477.84s)
account. And so as they create an
[24:39] (1479.60s)
account in the background um there's an
[24:42] (1482.32s)
API call to the circle APIs that
[24:44] (1484.40s)
provisions a wallet for each of those
[24:46] (1486.32s)
actual parties.
[24:49] (1489.12s)
And then the next thing is the actual uh
[24:52] (1492.24s)
business will take basically a PDF
[24:55] (1495.44s)
version of an agreement that they have
[24:57] (1497.60s)
with that actual freelancer um that they
[25:00] (1500.80s)
probably negotiated outside of the the
[25:03] (1503.20s)
platform uh for this use case. uh and
[25:06] (1506.24s)
then they would upload that agreement
[25:08] (1508.56s)
and what would happen is once they
[25:10] (1510.00s)
upload that agreement to the platform it
[25:12] (1512.56s)
would pass it to the open a uh open AI's
[25:16] (1516.80s)
u API and run it through uh a multimodal
[25:20] (1520.64s)
model to actually parse out information
[25:23] (1523.12s)
about the actual agreement and so that
[25:25] (1525.36s)
information will be related to you know
[25:27] (1527.52s)
the the amount um uh that these two
[25:30] (1530.48s)
parties have agreed upon as far as the
[25:32] (1532.24s)
work is concerned and then the uh the
[25:34] (1534.64s)
summary of task has that need to be
[25:36] (1536.08s)
delivered in order for the actual um
[25:39] (1539.20s)
escrow to be um completed and payout to
[25:42] (1542.80s)
happen. And so after that happens,
[25:46] (1546.80s)
basically there's a listing on the
[25:48] (1548.72s)
platform uh that the uh AI agent
[25:53] (1553.44s)
generates and and lists and there's a
[25:55] (1555.92s)
human in the loop in this process where
[25:58] (1558.16s)
you know the actual business approves
[26:00] (1560.00s)
that hey this is the amount I'd agreed
[26:02] (1562.16s)
upon. This is the list of um you know
[26:05] (1565.28s)
things that need to be done in order to
[26:06] (1566.96s)
honor the agreement and receive payout
[26:09] (1569.44s)
and uh and this is a good summary of
[26:11] (1571.52s)
what the agreement is about. So I want
[26:13] (1573.84s)
to publish that listing to the platform
[26:16] (1576.08s)
and then after that happens
[26:19] (1579.44s)
then the actual business would need to
[26:22] (1582.88s)
um create a smart contract. And so since
[26:26] (1586.16s)
we've already got a template running in
[26:27] (1587.84s)
the background they're not designing
[26:29] (1589.36s)
that smart contract themselves. What it
[26:31] (1591.76s)
is doing is it's taking the information
[26:34] (1594.64s)
u that the agent has parsed out from the
[26:36] (1596.80s)
actual contractual agreement and
[26:39] (1599.20s)
initializing certain constructor
[26:40] (1600.96s)
variables uh for the actual smart
[26:43] (1603.84s)
contract to be in a ready state to be
[26:45] (1605.76s)
deployed on chain to govern the rules of
[26:48] (1608.88s)
the actual agreement. And so those
[26:50] (1610.88s)
things are is just simple things right
[26:53] (1613.28s)
now. It's just use USDC as the stable
[26:56] (1616.08s)
coin of choice for the currency that
[26:57] (1617.76s)
flows through. Um also too, um the agent
[27:02] (1622.48s)
will will be um given a a wallet uh that
[27:06] (1626.24s)
can only be used to actually release
[27:08] (1628.24s)
funds from the contract. And then who is
[27:11] (1631.12s)
the um you know depositor wallet and who
[27:14] (1634.48s)
is the beneficiary wallet. And so those
[27:17] (1637.36s)
rules will be will be um enforced within
[27:20] (1640.40s)
the smart contract um before it's
[27:23] (1643.20s)
deployed on chain. And so after um so so
[27:27] (1647.84s)
to deploy it on chain, we're using the
[27:30] (1650.08s)
circle APIs for this. And so um after
[27:33] (1653.92s)
that that is deployed on chain, there's
[27:35] (1655.84s)
a notification that comes on the screen
[27:37] (1657.60s)
telling the actual business that the
[27:39] (1659.12s)
contract has been deployed successfully.
[27:41] (1661.44s)
Um, and in the background, a developer
[27:44] (1664.00s)
can use uh the developer console that we
[27:46] (1666.88s)
have at Circle to track all this
[27:48] (1668.56s)
activity uh and to design web hook
[27:51] (1671.20s)
notifications uh as well around this
[27:54] (1674.08s)
activity. And so that's one of the
[27:55] (1675.84s)
powers of um our dev console. allow for
[27:58] (1678.48s)
you to do a lot with onchain data uh
[28:02] (1682.00s)
because we're indexing all this
[28:03] (1683.60s)
information and putting it in a nice
[28:05] (1685.52s)
format to allow you to design different
[28:07] (1687.52s)
programmable flows around that
[28:09] (1689.12s)
information that's happening on chain.
[28:12] (1692.00s)
And so
[28:14] (1694.08s)
once the actual contract has been
[28:16] (1696.40s)
deployed on chain, the next thing is
[28:19] (1699.84s)
you're going to have to the business
[28:21] (1701.76s)
will have to actually on-ramp into USDC
[28:24] (1704.80s)
or if they have pure USDC, then they can
[28:27] (1707.84s)
uh fund that that um actual contract
[28:30] (1710.56s)
from um some USDC they already have an
[28:33] (1713.60s)
external wallet. And so, um, you will
[28:37] (1717.60s)
deposit, you'll call the actual deposit,
[28:40] (1720.16s)
uh, function on the smart contract. And
[28:42] (1722.72s)
what that would do is that would
[28:44] (1724.48s)
basically um initiate an approval for a
[28:47] (1727.60s)
certain amount of USDC to be sweeped
[28:51] (1731.60s)
from your actual wallet address and
[28:54] (1734.24s)
transferred into the smart contract so
[28:57] (1737.28s)
that the smart contract can go into a
[28:59] (1739.36s)
ready state of letting the beneficiary
[29:01] (1741.44s)
know funds have been deposited in the
[29:03] (1743.92s)
smart contract. Now it's ready for you
[29:07] (1747.04s)
to do the work you need to do to honor
[29:09] (1749.12s)
the contract. And so that's that's one,
[29:12] (1752.72s)
you know, magical moment where you have
[29:15] (1755.44s)
now in this escrow experience a smart
[29:18] (1758.32s)
contract that's actually holding the
[29:20] (1760.16s)
money in code and there is some sort of
[29:23] (1763.12s)
transparency that you know the money
[29:24] (1764.96s)
actually is there because you're dealing
[29:28] (1768.00s)
with these public networks that have the
[29:30] (1770.56s)
ability to verify, you know, that
[29:32] (1772.72s)
information by just looking it up on the
[29:34] (1774.64s)
block explorer to be able to see that,
[29:36] (1776.72s)
okay, funds are actually in this smart
[29:38] (1778.80s)
contract. So I know this person's
[29:40] (1780.96s)
serious about paying me. So um after
[29:48] (1788.00s)
then the actual um freelancer
[29:52] (1792.16s)
will and for for this actual experience
[29:54] (1794.88s)
we we use an image. Um they the the task
[29:59] (1799.60s)
at hand was to design basically um uh
[30:02] (1802.96s)
some marketing material in the format of
[30:04] (1804.88s)
an image um that had certain things
[30:08] (1808.40s)
within that image um that promoted the
[30:12] (1812.24s)
brand of the actual business. And so
[30:15] (1815.60s)
Freelancer uploads that image to the
[30:18] (1818.80s)
platform. It passes it off to uh OpenAI
[30:23] (1823.20s)
and the agent goes to work and it it
[30:25] (1825.28s)
looks and verifies. Okay, does this
[30:27] (1827.28s)
image have all the things in it that you
[30:29] (1829.76s)
know were required of it in the actual
[30:32] (1832.40s)
task agreement? If it does, then it'll
[30:36] (1836.32s)
go through a simple scoring system. uh
[30:39] (1839.28s)
and and if that system scores it as you
[30:42] (1842.00s)
know it's confidence level high that
[30:44] (1844.00s)
means okay yes release funds from the
[30:47] (1847.52s)
actual smart contract and then the agent
[30:50] (1850.08s)
uh can use its wallet to actually call a
[30:53] (1853.20s)
release uh funds function within the
[30:55] (1855.76s)
smart contract that will ultimately
[30:58] (1858.00s)
release funds to the beneficiaries
[31:00] (1860.40s)
wallet. And so this is where like the
[31:02] (1862.96s)
automation, the verification happens. Uh
[31:06] (1866.40s)
where in most escrow situations, there's
[31:08] (1868.96s)
a lot of convoluted back-end office work
[31:11] (1871.60s)
where manual review is being done and
[31:15] (1875.04s)
agents now are getting to the point
[31:16] (1876.80s)
where they're they're very good at uh
[31:18] (1878.96s)
reading, seeing, hearing, doing a lot of
[31:21] (1881.12s)
things. And so what what we think is u
[31:23] (1883.84s)
there could be a future where agents
[31:26] (1886.16s)
could be a major checkpoint in a lot of
[31:30] (1890.08s)
escrow transactions and coupled with
[31:33] (1893.92s)
USDC becoming a great way to settle es
[31:38] (1898.00s)
escrow transactions instantly when you
[31:40] (1900.00s)
combine all this together you can build
[31:42] (1902.56s)
some very um cool stuff together. Yeah.
[31:47] (1907.36s)
So I did a lot of talking. Let me uh
[31:51] (1911.04s)
show the demo because I I know people
[31:53] (1913.44s)
want to see that. Um so let me get out
[31:56] (1916.88s)
of here and open up my um
[32:06] (1926.00s)
All right. Let's see.
[32:11] (1931.92s)
All right. Can everyone see this? Okay.
[32:15] (1935.12s)
Okay. All right. Thanks. Okay. So,
[32:17] (1937.44s)
here's the escro agent app. I'm already
[32:19] (1939.60s)
logged in. Um,
[32:22] (1942.40s)
and I have some transactions that I've
[32:24] (1944.56s)
already set up because I wanted to show
[32:26] (1946.72s)
you what things look like in each state.
[32:28] (1948.48s)
And then I I'll kind of walk through
[32:30] (1950.16s)
certain transactions and and get to the
[32:32] (1952.96s)
actual cool part of actually um letting
[32:35] (1955.76s)
the agent actually release funds. But um
[32:38] (1958.48s)
here's a here's a transaction I've
[32:40] (1960.16s)
staged and right now it's in the
[32:42] (1962.64s)
initiated status. And so this status is
[32:45] (1965.68s)
someone has already uploaded a contract
[32:48] (1968.40s)
uh in PDF form to the platform. It's
[32:50] (1970.96s)
parsed out the information with the
[32:52] (1972.40s)
agent u using um the 40 mini model and
[32:56] (1976.24s)
then uh that human in the loop process
[32:59] (1979.52s)
of approving that hey this this is what
[33:02] (1982.48s)
you know the agreement should look like
[33:04] (1984.56s)
uh listed on the platform so that the
[33:06] (1986.96s)
beneficiary can receive that listing.
[33:09] (1989.28s)
And so this is the state of what it
[33:10] (1990.88s)
looks like after you get past that. So,
[33:13] (1993.20s)
it's showing you um the summary of the
[33:15] (1995.28s)
agreement. Uh obviously has the amount
[33:17] (1997.84s)
here of $10. And then here are some of
[33:21] (2001.76s)
the deliverables. Uh high quality image,
[33:24] (2004.40s)
you know, featuring Sparkle Fizzle. Uh
[33:27] (2007.12s)
so that's the brand fictitious company
[33:29] (2009.52s)
we created. And um and so this is what
[33:32] (2012.56s)
it'll look like before a smart contract
[33:35] (2015.28s)
is deployed to govern the rules of a
[33:38] (2018.72s)
actual agreement.
[33:42] (2022.88s)
Now in this state say I clicked deploy
[33:46] (2026.00s)
smart contract on chain. It has now
[33:49] (2029.12s)
built out the logic and the rules that
[33:51] (2031.84s)
will govern this um this agreement. Um
[33:54] (2034.72s)
the next thing is you know depositing
[33:56] (2036.96s)
funds in the smart contract. So the
[33:58] (2038.64s)
actual beneficiary knows that uh you
[34:01] (2041.20s)
know this person's serious. The money is
[34:03] (2043.44s)
there. It's time for me to go to work
[34:05] (2045.12s)
and and do the things so I can receive
[34:06] (2046.96s)
the money. Um this is what state will
[34:09] (2049.52s)
look like. Uh, and then if you hit this
[34:11] (2051.68s)
button, you can deposit funds and it
[34:13] (2053.52s)
will withdraw the $10 amount from your
[34:16] (2056.40s)
account balance and it'll deposit it in
[34:18] (2058.48s)
the actual smart contract and provide a
[34:20] (2060.32s)
notification of when that money has
[34:22] (2062.40s)
settled in the actual smart contract.
[34:24] (2064.80s)
And then once it's, you know, in the
[34:27] (2067.04s)
smart contract, the state will move to
[34:30] (2070.40s)
locked. And so that means the smart
[34:32] (2072.00s)
contract will lock itself. And and now
[34:34] (2074.72s)
the the next thing that can happen in
[34:38] (2078.08s)
that smart contract is basically the
[34:40] (2080.96s)
agent actually reviewing the work and
[34:44] (2084.08s)
interacting with it to either release
[34:46] (2086.48s)
the funds or um you know revert the
[34:50] (2090.16s)
actual funds back to the actual um
[34:54] (2094.16s)
depositor. uh if you know a period of
[34:56] (2096.88s)
time elapses where you know that person
[34:59] (2099.68s)
was never able to kind of meet the
[35:01] (2101.28s)
agreement.
[35:03] (2103.92s)
So um what I'll do now is let me um run
[35:09] (2109.76s)
through a test transaction.
[35:12] (2112.32s)
Okay. So let's see
[35:16] (2116.40s)
design.
[35:32] (2132.72s)
So, here's a PDF document. Going to
[35:35] (2135.68s)
upload it.
[35:40] (2140.08s)
Let's see.
[35:46] (2146.88s)
All right. So, in the background, the
[35:48] (2148.88s)
agent was running parsing out the
[35:50] (2150.80s)
information in the PDF document. Again,
[35:53] (2153.84s)
um it's it's parsed out the amount and
[35:56] (2156.16s)
the task. And so, if I hit continue,
[36:00] (2160.40s)
what it's going to do is it's going to
[36:02] (2162.72s)
generate that listing on the platform.
[36:10] (2170.96s)
So, we've got our web hook working. It's
[36:12] (2172.96s)
passing updates
[36:14] (2174.96s)
uh to make sure
[36:17] (2177.60s)
And let me do a refresh so that listing
[36:20] (2180.64s)
will show.
[36:26] (2186.48s)
Yeah. Okay. Yep. So that's the listing.
[36:30] (2190.32s)
Um and so now
[36:34] (2194.08s)
what we want to do is um we want to
[36:37] (2197.44s)
create a smart contract. So um because
[36:40] (2200.24s)
it has all the information that it needs
[36:42] (2202.16s)
to actually create this agreement now on
[36:44] (2204.16s)
chain. So we hit create smart contract.
[36:48] (2208.40s)
What it's doing now is calling the
[36:49] (2209.92s)
circle APIs to actually uh deploy that
[36:53] (2213.52s)
contract on chain. So
[36:57] (2217.04s)
may take a little time but uh
[37:01] (2221.60s)
it should work in a few minutes. Let's
[37:12] (2232.40s)
Uh actually great question. Uh the
[37:14] (2234.16s)
network I'm using is base. Yeah. Yeah.
[37:17] (2237.92s)
Yeah. No, no, no. I mean is is a great
[37:21] (2241.60s)
partner. Um but um but we we support you
[37:25] (2245.28s)
know all the a lot of different chains.
[37:27] (2247.68s)
Yeah. Let me see taking a little time.
[37:32] (2252.72s)
I got a follow. Can you do an escro
[37:35] (2255.12s)
crosschain or does it have to be single?
[37:39] (2259.36s)
Um yeah, you actually can perform
[37:42] (2262.88s)
crosschain extra escrow experiences.
[37:46] (2266.16s)
Um you can use our crosschain transfer
[37:49] (2269.44s)
protocol to do that. So I'll give you
[37:51] (2271.52s)
example of how maybe that would look is
[37:53] (2273.76s)
it's more of uh maybe a crosschain
[37:56] (2276.48s)
deposit. So maybe someone comes to the
[37:58] (2278.48s)
platform and the contracts are on base
[38:02] (2282.24s)
but their USDC is on Salana and so they
[38:06] (2286.16s)
want to deposit from Salana USDC to base
[38:09] (2289.76s)
they can send it over the crosschain
[38:11] (2291.28s)
transfer protocol CCTP right and then it
[38:14] (2294.40s)
will deposit into that base contract and
[38:17] (2297.04s)
then if the beneficiary says hey you
[38:19] (2299.60s)
know like I'm not on base I'm on you
[38:22] (2302.08s)
know another chain Ethereum I want it on
[38:24] (2304.24s)
Ethereum then you can do crosschain, you
[38:28] (2308.00s)
know, payout from that contract. Oh, so
[38:30] (2310.40s)
it's not actually part of the contract.
[38:32] (2312.96s)
Right. Right. So, so usually what we've
[38:35] (2315.36s)
seen as developers who are building um
[38:38] (2318.40s)
crosschain experiences where they're
[38:41] (2321.12s)
dealing with smart contracts, escrow, uh
[38:44] (2324.48s)
a lot of them pick like one chain where
[38:46] (2326.80s)
the actual contracts will live and then
[38:49] (2329.12s)
they build interoperability between like
[38:51] (2331.36s)
deposit and payout flows. Yeah. Yeah.
[38:56] (2336.40s)
Uh let's see
[39:01] (2341.12s)
me go here to the
[39:04] (2344.40s)
oops wrong one.
[39:07] (2347.74s)
[Music]
[39:10] (2350.56s)
Let's see something.
[39:31] (2371.36s)
So, yeah, it's working. It's pending.
[39:33] (2373.04s)
It's just taking some time, little
[39:34] (2374.80s)
latency here to actually deploy the
[39:37] (2377.36s)
contract. Um so these are these are
[39:40] (2380.96s)
different contracts I deployed testing
[39:42] (2382.64s)
it. So this based upon your
[39:48] (2388.48s)
let's see
[39:54] (2394.24s)
actually what I'm going to do let me let
[39:56] (2396.08s)
me show this cool video so you all can
[39:58] (2398.08s)
see like end to end really quickly
[40:00] (2400.16s)
because there is you know some sort of
[40:03] (2403.68s)
uh latency around the internet in here.
[40:12] (2412.80s)
I'll play this video right quick so you
[40:15] (2415.92s)
guys can see it in the inflow of like
[40:18] (2418.00s)
how it works.
[41:14] (2474.88s)
And so another thing too um is you know
[41:19] (2479.20s)
you don't have to worry about gas with
[41:21] (2481.52s)
these uh with using our tooling because
[41:23] (2483.76s)
you can design these experiences and
[41:25] (2485.36s)
then we have built-in gas abstraction
[41:28] (2488.00s)
with our wallet uh as a service infra um
[41:30] (2490.96s)
and so it enables you to really abstract
[41:33] (2493.68s)
away kind
[41:35] (2495.28s)
dealing with, you know, holding native
[41:37] (2497.20s)
tokens for gas. And so we also uh make
[41:40] (2500.24s)
it very easy for, you know, as we're
[41:42] (2502.48s)
abstracting the gas away, obviously
[41:44] (2504.16s)
there's a cost there, but we make it
[41:45] (2505.84s)
easy for you to actually uh pay for your
[41:48] (2508.32s)
gas fees from fiat um directly from a
[41:51] (2511.52s)
debit card that you would or a credit
[41:53] (2513.12s)
card that you put on file. Um, but we we
[41:56] (2516.88s)
really have uh designed this for, you
[41:58] (2518.72s)
know, enterprises um that, you know,
[42:01] (2521.76s)
probably aren't web 3 native to be able
[42:04] (2524.48s)
to integrate our technology, take
[42:07] (2527.12s)
advantage of the near instance
[42:09] (2529.28s)
settlement that comes with public
[42:11] (2531.36s)
blockchain networks and manage wallets
[42:14] (2534.64s)
and transactions at a scalable level to
[42:17] (2537.44s)
be able to um, you know,
[42:20] (2540.72s)
expand their their actual footprint of
[42:23] (2543.20s)
of payments around in the world.
[42:27] (2547.60s)
So, um the last thing I have is um
[42:41] (2561.36s)
deploying the contracts.
[42:49] (2569.44s)
Yeah. you you can actually deploy like a
[42:52] (2572.00s)
contract factory uh and then that'll
[42:54] (2574.48s)
allow you to kind of create iterations
[42:57] (2577.04s)
of that within the contract factory to
[42:59] (2579.36s)
be more efficient on the gas. Yeah.
[43:09] (2589.36s)
So in the mechanics of what you're doing
[43:11] (2591.04s)
is that first step basically taking the
[43:13] (2593.84s)
an unstructured document and you
[43:15] (2595.44s)
creating basically structured data to
[43:17] (2597.12s)
then feed to the circle API in terms of
[43:19] (2599.84s)
and I guess how does that piece work? Is
[43:22] (2602.40s)
it as as simple as like feeding the
[43:24] (2604.24s)
contract to open API and just doing a
[43:27] (2607.20s)
little prompting to kind of get the
[43:28] (2608.56s)
structured data you want as far as the
[43:30] (2610.64s)
JSON format? Yeah, I'll jump into this
[43:33] (2613.04s)
right quick for you. So, okay.
[43:39] (2619.52s)
So, yeah, that first um part is, you
[43:43] (2623.20s)
know, we've created a prompt to make
[43:45] (2625.28s)
sure it outputs it in JSON. So, it
[43:47] (2627.76s)
parses things out, outputs it in kind of
[43:50] (2630.24s)
a JSON format that looks like this. Uh
[43:53] (2633.28s)
and then uh that's how we're able to
[43:55] (2635.44s)
kind of feed it through to be able to um
[43:58] (2638.80s)
create basically that listing that
[44:00] (2640.72s)
adheres to uh a consistent format of of
[44:04] (2644.32s)
um showing the actual transaction um
[44:07] (2647.84s)
amount and task. I'm not super familiar
[44:10] (2650.48s)
with escrow contracts. Are they fairly
[44:14] (2654.00s)
standardized or they come in different
[44:15] (2655.84s)
forms? And I guess how uh robust has it
[44:20] (2660.96s)
been able to be in terms of handling
[44:22] (2662.64s)
different uh formats?
[44:25] (2665.12s)
Yeah. So um here's the actual solidity
[44:28] (2668.00s)
code. I'll show you uh for the actual
[44:30] (2670.88s)
escrow contract here. Uh and it this is
[44:35] (2675.84s)
a very simple one. Um it's only like a
[44:38] (2678.56s)
couple hundred lines uh and a few
[44:40] (2680.48s)
functions. they can get uh very robust.
[44:44] (2684.40s)
But if you're um for most for most
[44:48] (2688.96s)
escrow um you know experiences
[44:52] (2692.40s)
uh this could cover a lot you know for
[44:54] (2694.88s)
most escro experiences and there are a
[44:57] (2697.04s)
lot of templates out there um since
[44:59] (2699.84s)
escrow has been a big thing in the
[45:01] (2701.84s)
actual crypto ecosystem um that you can
[45:05] (2705.20s)
use. one um is is one that um our
[45:09] (2709.68s)
research team worked on. It's called the
[45:12] (2712.16s)
refund protocol. Uh I'll pull it up
[45:14] (2714.56s)
right now, but it's a it's an escrow
[45:16] (2716.08s)
template that kind of gives you all the
[45:17] (2717.44s)
robustness you would probably need to
[45:19] (2719.20s)
handle um any type of escrow scenario uh
[45:23] (2723.68s)
that that has been prevalent in the
[45:26] (2726.00s)
ecosystem. Let me pull it up right now.
[45:28] (2728.48s)
And um you could actually use that uh
[45:31] (2731.84s)
and as a template and and you know add
[45:34] (2734.40s)
to it if you want or just use it
[45:36] (2736.32s)
straight out of the box.
[45:40] (2740.88s)
So let me show you this one.
[45:52] (2752.36s)
[Music]
[45:56] (2756.96s)
Yeah, here it is. right here.
[46:00] (2760.24s)
So if you go to circle research,
[46:02] (2762.96s)
uh this is an article about it and it
[46:06] (2766.00s)
kind of explains, you know, the
[46:07] (2767.92s)
functionality built into it. But also
[46:10] (2770.08s)
too, we have a repo. Um it is
[46:15] (2775.20s)
where is this repo?
[46:23] (2783.92s)
Refund protocol. So yeah, this one right
[46:26] (2786.24s)
here. You could use this as a template.
[46:32] (2792.24s)
Can you just wait for the microphone so
[46:34] (2794.72s)
everybody could hear you? Hold on one
[46:36] (2796.24s)
second.
[46:44] (2804.80s)
Thank you.
[46:47] (2807.44s)
Okay. Um so my my question here is uh
[46:51] (2811.04s)
towards the challenges of minimizing
[46:53] (2813.28s)
human intervention. Um I I find uh LM
[46:58] (2818.32s)
and agents um
[47:01] (2821.92s)
sometimes unreliably
[47:04] (2824.32s)
non deterministic right so there is
[47:07] (2827.92s)
always this pattern of um the LM or the
[47:12] (2832.08s)
agent builds like a plan and someone
[47:14] (2834.80s)
reviews to approve
[47:17] (2837.20s)
um given the nature of um your business
[47:21] (2841.76s)
right I I understand that Like
[47:26] (2846.32s)
I guess the question here is like what
[47:28] (2848.40s)
are for circle AI the biggest challenges
[47:32] (2852.24s)
when you talk about minimizing human
[47:34] (2854.56s)
interaction using
[47:36] (2856.96s)
yeah great great question. Um so the
[47:40] (2860.72s)
question here is you know what what is
[47:43] (2863.68s)
um the challenges with minimizing
[47:47] (2867.36s)
interactions with payments as it relates
[47:49] (2869.60s)
to circle. Um, so I think that um,
[47:55] (2875.44s)
our focus as our company is kind of like
[47:59] (2879.36s)
creating more of a frictionless exchange
[48:01] (2881.60s)
of value using public blockchain
[48:04] (2884.24s)
networks for settlement, right? But we
[48:07] (2887.36s)
started to see a huge trend uh over a
[48:10] (2890.80s)
year ago where u a lot of developers
[48:13] (2893.44s)
were building agentic workflows using
[48:17] (2897.28s)
USDC is the payment rail of choice to
[48:19] (2899.68s)
transact between agents and agents. And
[48:22] (2902.56s)
so um what we we think is um obviously
[48:28] (2908.48s)
there um the the one thing about you
[48:31] (2911.20s)
know um AI is it's not deterministic and
[48:35] (2915.76s)
payments are deterministic.
[48:38] (2918.24s)
Uh you want them to be deterministic but
[48:40] (2920.96s)
there is a lot of conditional logic that
[48:44] (2924.00s)
is happening before payments are being
[48:47] (2927.60s)
released in the world. And so um what
[48:51] (2931.36s)
what I think is right now the best
[48:54] (2934.48s)
safest way to design these experiences
[48:57] (2937.52s)
is with human in the loop built into it.
[49:00] (2940.80s)
Um and and and really kind of focus on
[49:05] (2945.28s)
it doing being just a pure review
[49:09] (2949.28s)
basically for a person in a actual um
[49:13] (2953.84s)
payment operation u job to be able to
[49:17] (2957.28s)
have just something else out there that
[49:19] (2959.68s)
is doing work 24/7 and saying hey here
[49:22] (2962.48s)
are a list of payments that are ready to
[49:24] (2964.48s)
go and this is what we've analyzed and
[49:28] (2968.24s)
why we believe it's ready to go but at
[49:30] (2970.16s)
the end end of the day like you're the
[49:31] (2971.76s)
final approver. Uh and so that's what we
[49:35] (2975.36s)
think um you know in the near future
[49:38] (2978.24s)
combining these technology together uh
[49:41] (2981.04s)
it can be a great combination but
[49:43] (2983.52s)
autonomously and just you know full
[49:46] (2986.48s)
automation of controlling um sending and
[49:49] (2989.92s)
receiving payments I'm not sure we're
[49:52] (2992.08s)
there right now. Uh but I will say that
[49:55] (2995.28s)
um you know the way this AI industry is
[49:58] (2998.48s)
moving um there could be a world you
[50:02] (3002.48s)
know 5 to 10 years from now where um
[50:05] (3005.68s)
people actually trust these agents to
[50:07] (3007.84s)
autonomously handle um payments um and
[50:12] (3012.56s)
procurement and things like that. So
[50:15] (3015.28s)
hopefully that answers your question.
[50:17] (3017.28s)
Yeah, but we're we're in the first
[50:19] (3019.60s)
inning of this and to be completely
[50:22] (3022.80s)
transparent, you know, there's people in
[50:24] (3024.24s)
this room who have a lot of experience
[50:26] (3026.08s)
building with agents. Um, this is
[50:28] (3028.48s)
designed to inspire you all to like test
[50:31] (3031.04s)
out the combination of this technology
[50:33] (3033.20s)
and and and and give us feedback, too.
[50:35] (3035.60s)
Uh, we're learning alongside. Oh. Oh.
[50:38] (3038.56s)
Um, I missed the first part, but what's
[50:41] (3041.60s)
the closest real life examples you have
[50:43] (3043.92s)
of this autonomous work evaluation and
[50:47] (3047.44s)
settlement? Do you have any kind of real
[50:49] (3049.44s)
life examples you can share? Yeah. Um,
[50:52] (3052.88s)
so we we haven't released any anything
[50:55] (3055.76s)
that's like in production doing this,
[50:58] (3058.16s)
but there are companies that are doing
[51:02] (3062.72s)
this right now in production. Um and
[51:07] (3067.68s)
that is you know you have crossmit is
[51:10] (3070.24s)
one company uh and then another company
[51:13] (3073.60s)
is um third web with Nebula uh their
[51:17] (3077.44s)
model. So those companies are kind of
[51:20] (3080.08s)
you know on the bleeding edge of of
[51:22] (3082.00s)
offering these experiences to developers
[51:24] (3084.32s)
but also kind of you know putting things
[51:26] (3086.48s)
out themselves. So I'd encourage you to
[51:28] (3088.88s)
check out those two companies. They're
[51:30] (3090.40s)
both uh Crossman's headquartered in New
[51:32] (3092.96s)
York, I think, and uh Third Webb is
[51:36] (3096.32s)
right down the street here in the Bay.
[51:37] (3097.84s)
Yeah. Yeah. Um hi. Um I have a question
[51:42] (3102.96s)
regarding like around the escro
[51:45] (3105.04s)
transactions. So I wanted to know how
[51:47] (3107.84s)
feasible uh is it to implement Jon proof
[51:51] (3111.84s)
um in this blockchain based escro
[51:54] (3114.08s)
transactions.
[51:55] (3115.92s)
Yeah. um that that is um that's
[51:58] (3118.96s)
something that is is pretty feasible
[52:00] (3120.80s)
with the advancements that we've seen
[52:03] (3123.28s)
with um proving TLS notary
[52:07] (3127.28s)
communications. Um those a little bit
[52:10] (3130.00s)
lighter weight to prove and you can
[52:12] (3132.24s)
generate a proof faster and pass that to
[52:14] (3134.56s)
a smart contract to be able to um
[52:17] (3137.52s)
perform uh escrow. Uh so there is a
[52:22] (3142.08s)
company called ZKP P2P that actually is
[52:24] (3144.64s)
experimenting with this and it's a live
[52:26] (3146.64s)
experiment that is working really well.
[52:28] (3148.96s)
So um there are different ways you could
[52:30] (3150.80s)
you could design these and integrate ZK
[52:33] (3153.36s)
proofs into them um that we've seen and
[52:36] (3156.40s)
and ZKP is one of them that has done it
[52:39] (3159.12s)
pretty well. Yeah, great question. Yeah,
[52:41] (3161.76s)
thank you. I have sorry I have another
[52:43] (3163.92s)
question as well. So uh could you go to
[52:46] (3166.40s)
the slide where the uh implementation
[52:49] (3169.92s)
thing is there for the cold storage
[52:51] (3171.60s)
support?
[52:53] (3173.52s)
Okay let's see
[52:58] (3178.64s)
so here I have a doubt like
[53:08] (3188.40s)
um so yes in this like transactions
[53:11] (3191.28s)
should not all uh always be
[53:13] (3193.20s)
instantaneous. So you should be like
[53:15] (3195.76s)
creating ahead of time and broadcast
[53:17] (3197.68s)
next month, right? So I'm not sure like
[53:21] (3201.04s)
I I haven't done like if is there a
[53:23] (3203.28s)
possibility if like uh there might be a
[53:25] (3205.68s)
double spending kind of attack if we
[53:28] (3208.32s)
like hold uh the transaction and it is
[53:31] (3211.12s)
not spontaneous.
[53:33] (3213.20s)
Um so the the question is could actually
[53:38] (3218.40s)
u generating an offline transaction
[53:40] (3220.88s)
that's approved create a double spending
[53:44] (3224.80s)
uh exploit is that that that the
[53:47] (3227.04s)
question? Um yes. Uh um I don't think it
[53:52] (3232.16s)
could could necessarily do that. Um, you
[53:56] (3236.00s)
know, from from my experience of of
[53:58] (3238.08s)
people actually kind of generating
[54:00] (3240.24s)
transactions offline to actually
[54:02] (3242.48s)
broadcast later, I haven't seen that
[54:05] (3245.12s)
that issue become uh a problem with
[54:08] (3248.24s)
double spending. Oh. Oh, no. And like uh
[54:10] (3250.88s)
could you like little bit uh explain me
[54:12] (3252.88s)
the scenario of like how transactions
[54:15] (3255.44s)
should not always be instantaneous like
[54:18] (3258.16s)
around this? So, so this this use case
[54:21] (3261.20s)
of me maybe if you are a company and
[54:23] (3263.20s)
you're running payroll on chain and um
[54:26] (3266.64s)
you know that um there is a transaction
[54:29] (3269.76s)
that you're going to make in the future
[54:31] (3271.92s)
um for a certain amount to do payroll
[54:33] (3273.92s)
and it's on a consistent cadence. You
[54:36] (3276.32s)
could actually uh generate that
[54:38] (3278.40s)
transaction, sign it and approve it
[54:40] (3280.40s)
offline and then broadcast it on the day
[54:43] (3283.68s)
of the actual transaction that needs to
[54:45] (3285.84s)
be sent out. Oh, got it. Thank you.
[54:48] (3288.48s)
Yeah. Okay.
[54:57] (3297.84s)
Hey, how's it going? Good. How you
[54:59] (3299.28s)
doing? I must have missed the first part
[55:01] (3301.36s)
where you mentioned multi-IG but um my
[55:04] (3304.00s)
question was just revolving around like
[55:06] (3306.16s)
some of the different use cases of
[55:07] (3307.36s)
multi-ig combining that with you know
[55:10] (3310.00s)
humans agents um you know for example in
[55:13] (3313.76s)
this um contract evaluation you could
[55:16] (3316.56s)
have like three different agents try to
[55:19] (3319.28s)
evaluate the same contract and criteria
[55:21] (3321.84s)
inside of multiig but what other what
[55:23] (3323.76s)
other use cases of multi-IG and AI do
[55:26] (3326.32s)
you see?
[55:28] (3328.80s)
Great question. Um, you know, I I think
[55:32] (3332.56s)
that um, you know, there could be a
[55:34] (3334.72s)
world where um, you like you you have
[55:38] (3338.24s)
multiple agents that may act as um, you
[55:42] (3342.08s)
know, in in kind of like a a financial
[55:45] (3345.52s)
uh, operations unit at a company, small
[55:48] (3348.56s)
company, and you may have um, you know,
[55:51] (3351.36s)
a CFO agent, a controller agent,
[55:54] (3354.48s)
accountant agent, and those agents are
[55:57] (3357.76s)
cross-checking each other's work and
[55:59] (3359.36s)
things like that. But then ultimately
[56:01] (3361.52s)
they need to do uh some sort of multi-
[56:04] (3364.24s)
signature process to be able to sign off
[56:06] (3366.56s)
on uh maybe transactions that are over
[56:09] (3369.04s)
like $25,000.
[56:11] (3371.04s)
Um so that that could be like a world
[56:13] (3373.04s)
that we see uh with with agents and um
[56:18] (3378.16s)
Great. Thank you. Yeah. Okay.
[56:26] (3386.56s)
So where you using that AI? um for
[56:30] (3390.08s)
reading the document and generating the
[56:32] (3392.40s)
like what the contract should be. So
[56:35] (3395.04s)
there is a human in the loop. Uh so for
[56:38] (3398.00s)
in order to the in order for the human
[56:39] (3399.84s)
to approve or reject it, he needs to go
[56:42] (3402.72s)
through that document himself as well,
[56:44] (3404.56s)
right? U so how exactly is that agent
[56:48] (3408.96s)
saving any effort because the human has
[56:52] (3412.24s)
to still go and read the document,
[56:54] (3414.08s)
right? Yeah. Yeah. So like you know
[56:56] (3416.80s)
right now like this is just a a a simple
[56:59] (3419.60s)
prototype, right? Um we could have gone
[57:02] (3422.24s)
the extra mile and started out with
[57:04] (3424.72s)
someone uh you know using NLP to like
[57:08] (3428.64s)
just create like
[57:10] (3430.96s)
a a simple prompt to say, "Hey, I want a
[57:13] (3433.20s)
contract between you know me and this
[57:14] (3434.96s)
other person that does these things."
[57:16] (3436.56s)
And then the agent goes out and writes
[57:18] (3438.08s)
it. And then the agent could actually,
[57:20] (3440.80s)
you know, um parse out the information
[57:23] (3443.44s)
that it wrote and then send a
[57:24] (3444.88s)
notification to the two parties that
[57:26] (3446.56s)
this is agreement for $100 and these are
[57:29] (3449.44s)
the things that need to be met. Um so
[57:31] (3451.76s)
that that's that's a world where we we
[57:33] (3453.36s)
could have done that but like we were
[57:35] (3455.04s)
just trying to put together a simple
[57:36] (3456.32s)
prototype to just showcase the
[57:38] (3458.08s)
combination of technology but this is
[57:40] (3460.88s)
not you know something we we feel like
[57:42] (3462.96s)
is you should you know deploy in
[57:46] (3466.24s)
production and use right now but it's in
[57:48] (3468.64s)
inspiration you know of combining these
[57:50] (3470.72s)
different technologies. Okay. Thanks.
[57:53] (3473.20s)
Yes. Yeah.
[57:58] (3478.32s)
So I guess um
[58:01] (3481.52s)
yeah uh we don't have any other
[58:04] (3484.24s)
questions. We can
[58:06] (3486.88s)
close it out.
[58:09] (3489.52s)
Thanks everyone.
[58:11] (3491.60s)
[Music]