This year, at least one well-known crypto agent platform had a significant incident where AI misinterpretation caused unintended transactions to execute before anyone could intervene. No manual override. No readable confirmation step. The speed that made the product appealing became the mechanism of the failure.

The industry is moving fast. But it is moving fast without answering a foundational question: how much autonomy is actually safe to hand to an AI in a financial context?

Subscribe now

The Autonomy Assumption

Most AI agent products in crypto are built on an autonomy-first model. The premise is that the AI should handle everything. Speed is the differentiator. The fewer clicks between intent and execution, the better the product.

That logic works well enough when the stakes are low. It breaks down at the intersection of irreversibility and financial risk.

Onchain transactions are final. There is no chargeback, no dispute resolution, no customer support team that can reverse a mistaken swap. When an AI agent acts on a misread input or an ambiguous instruction in that environment, the consequences are permanent.

What Human-in-the-Loop Actually Means

“Human-in-the-loop” has become a phrase that gets attached to products as a trust signal without much scrutiny of what it actually requires. A confirmation screen that shows a wallet address and a dollar figure is not “human-in-the-loop” in any meaningful sense. Most users cannot parse a raw transaction. They click confirm because they do not know what else to do.

Human-in-the-loop, properly implemented, means showing the user what is about to happen in plain language, at a level of detail that allows them to make a genuine decision. It means the agent proposes and the user approves, not the reverse. It means revocation is always possible, not buried menus deep into the UI.

This is harder to build than it sounds. It requires translating the complexity of smart contract interactions into something a non-technical user can actually evaluate. That translation work is where the real UX problem lives.

Speed and Control Are Not Opposites

The objection to human-in-the-loop design is usually that it slows everything down. If the user has to approve every transaction, what is the point of the agent?

The objection misunderstands the problem the agent is supposed to solve. For most DeFi users, the bottleneck is not the time spent clicking confirm. The bottleneck is the time spent understanding what to do, across which protocols, in what order, with what parameters. An agent that handles all of that and surfaces a clear, human-readable action for the user to approve has removed almost all of the friction. One confirmation step is not the friction.

The agent’s value is in the reasoning and the execution path, not in bypassing the user entirely.

The Trust Dividend

There is a practical case for human-in-the-loop controls that goes beyond safety. Users who feel in control use products more consistently. They take larger positions. They recommend the product to others. Trust is not a compliance checkbox. It is a growth variable.

Products that prioritise speed over control are betting on users who never encounter a problem. That is not a bet worth making in a space where smart contract exploits, front-running, and protocol failures are routine background noise.

What This Means for the Category

AI agents for crypto are arriving quickly. The category is still early enough that the design decisions being made now will define user expectations for years. The autonomy-first model is one answer. Human-in-the-loop is another. They are not equivalent.

The distinction matters most when something goes wrong. And in DeFi, something always eventually goes wrong.

The platforms that will win in AI-driven DeFi are not the ones that move fastest. They are the ones that move with enough transparency that users stay confident through the rough patches.

Share

The Problem That Apps Cannot Solve

The actual barrier to financial participation has never been the absence of an interface. It has been the gap between what people want and the technical vocabulary required to ask for it.

A user does not wake up wanting to rebalance their stablecoin exposure across L2s. They wake up wanting their savings to work harder, or to send money to family, or to hold dollars in a country where dollars are difficult to hold. The fintech industry has tended to design for the request after it has been translated into product language, not for the request as it lives in the user’s head.

This is why traditional bank UX still works, in a clunky way. Not because banks are good at design, but because a teller can hear, “I want to save for my kid’s school”, and route it without the customer needing to know what a money market fund is. The vocabulary problem gets solved by a human standing in front of you.

DeFi removed the human and left the vocabulary in place. And then, it added more of it.

Subscribe now

Why This Cuts Deeper Onchain

Onchain finance multiplies the language problem. There are dozens of chains, hundreds of protocols, and a lexicon that turns over every six months: Stake. Restake. Liquid stake. Restake the liquid stake. Each layer was a real engineering step forward. Each layer was also another translation a user had to do before they could even ask the question.

The industry’s response has mostly been to teach. Glossaries inside wallets. Tooltip explainers. Long blog posts walking through the new thing. This approach has a ceiling, because most people will never want to learn the vocabulary of finance any more than they want to learn the vocabulary of plumbing. They want the water to come out of the tap.

Of course there is always a small fraction of users who will always be deep operators. They read the docs, they run the nodes, they hold strong opinions about MEV. Everyone else has been waiting for the moment when they no longer have to.

What Changes When the Agent Does the Translation

AI changes this in a specific way. It is not that the protocols suddenly become easier. They are exactly as complex as they were. What changes is that the user no longer has to be the one doing the translation.

Plain language access to onchain finance is not a UX flourish. It is the precondition for the next set of users showing up at all. When you can say, “I have some idle ETH, what can it earn safely?”, and get a real, executable answer back, you are not using a friendlier app. You are using a different category of tool.

This is also why the translation layer matters more than the chat window that wraps it. The chat window is the visible part. The work happens underneath: parsing intent, choosing the chain, routing the swap, simulating the transaction, checking that the protocol is one you would actually want to touch. Done well, the user never sees any of it. Done badly, the user gets an agent that confidently does the wrong thing.

The Inclusion Argument, Reframed

If financial inclusion was ever a real goal and not just a fundraising line, the conversation should not be about how many people have a banking app installed on their phone. It should be about how many people can act on their financial intentions without having to learn a second language first.

By that measure, fintech has barely moved the needle. Onchain finance, with an agent layer on top, has a real shot at moving it. Not because the protocols are friendlier, because they are not. But because the user no longer has to meet the protocol on its terms.

The next billion participants in onchain finance will not arrive because we built better dapps. They will arrive because they finally got to ask, in their own words, for the thing they wanted. And something answered.

That is a different bet than the one the industry has been making for most of the last decade. Looking at the evidence, it may also be the only one that has ever had a chance of working.

AI agents are already doing real economic work. They book travel, manage subscriptions, rebalance portfolios, and pay other software for outputs. As that work expands, the financial system they sit on top of starts to matter. And the system humans use, the one made of banks, card networks, and brokerages, was not built to serve actors that are not people.

Share

The mismatch between banks and bots

Banks operate on a model that assumes a single accountable human signer. KYC ties accounts to people. Disputes assume intent. Settlement runs on batch windows tied to business hours. Authentication relies on phone numbers, biometrics, and other artefacts of human bodies. Strip those away and the bank cannot do its job.

You can layer agents on top with custodial wrappers, OAuth tokens, virtual cards, and shared credentials. People are trying. But every workaround leaves the same gap: the system still treats the agent as a proxy for a person, not as a participant in its own right. That is fine for narrow use cases. It breaks at scale.

Onchain rails were always agent ready

Smart contracts do not care whether the address calling them belongs to a person or a script. Settlement is final, programmable, and continuous. There are no business hours, no batch windows, no shared credentials to leak. Permissions can be granted, scoped, revoked, or sub-delegated in code rather than in legal agreements that nobody reads.

This was not designed for agents. It just happens to fit them better than anything else available. The same properties that early crypto enthusiasts argued for, censorship resistance, programmability, openness, are also the properties software actors need to function. The agent economy will not pick onchain rails because of ideology. It will pick them because they work.

The self-custody question gets sharper

Once agents start moving real money, the question of who holds the keys gets more urgent, not less. An agent that custodies user funds is a single point of failure. An agent that asks a custodian for permission introduces latency, gatekeepers, and another party to trust. Neither is acceptable for the work agents will be expected to do.

The model that survives is the one that already exists onchain: delegation. The user keeps the keys. The agent gets a permission, with limits the user defines. The agent acts within those limits and only those limits. Nothing in the bank stack works that way. Almost everything onchain can.

What this means for builders right now

If you are building agents that need to handle value, the rails question is no longer abstract. Custodial wrappers are a temporary patch. Banking-as-a-service vendors are not going to retrofit themselves around software actors fast enough. The serious infrastructure is being built onchain because that is where the constraints already line up.

This is what we are building at CoinFello: a permissioned execution layer where agents act on behalf of users, with delegated authority, hardware-isolated keys, and full transparency on every transaction. Not because onchain is fashionable, but because it is the only place an agent can do meaningful financial work without either holding your keys or being gated by a custodian.

The quiet migration

The shift will not feel dramatic. There will be no day when banks announce they are closing to agents. Instead, more and more of the financial work that humans used to do themselves will be handled by software. That work will need somewhere to live. The rails that fit will quietly absorb it, and the rails that do not fit will keep doing what they have always done, just for a shrinking share of activity.

If the next billion users of the financial system are software, the question is not whether they will use onchain rails. It is what those rails should look like, and who is going to take responsibility for building them well.

Subscribe now

The Trust Question Is a Trap

When you frame this as a trust question, you end up at one of two dead ends: either you decide AI is too risky to touch your money, and you sit out an entire wave of capability. Or you hand over custody to a service that promises it has things under control, and you trade one set of risks for another.

Both options assume that letting an agent act onchain requires letting the agent hold your funds. It does not. That assumption is a holdover from how traditional software works, not how smart contracts and modern wallet architecture work.

Permissions Are Cheaper Than Custody

The model that actually scales for agent driven finance is permission, not possession. You do not give an agent your wallet. You give it a scoped allowance. Daily limit, weekly limit, per token cap, with a fixed expiry. Revocable in a click.

This is what onchain delegation standards like ERC 7710 and ERC 7715 are for. They let a wallet say to an agent: you can move up to this much, of this asset, for this purpose, and nothing more. The keys never leave the wallet. The agent never holds them. It holds a permission slip, with the user as the authority on its scope.

That changes the entire risk profile. The worst case is no longer that the agent drained my wallet. It is that the agent used the allowance I had already authorised, and I can revoke the rest in seconds.

You Would Never Hire a Contractor Without a Scope of Work

Think about how you would actually hire a human to do something with your money. You would not hand over your bank login. You would tell them what you wanted done, set a budget, and ask them to come back to you for anything outside it.

That is the right mental model for an AI agent too. The agent is a contractor, not a custodian. Your wallet defines the scope of work. The agent operates inside it. If the work is good, you extend the scope. If it is not, you revoke and move on.

The custodial AI wallets gaining attention right now invert that relationship. They treat the agent, and the company running it, as the principal, and treat the user as the beneficiary of whatever the principal decides to do. That works until it does not, and the failure takes everything with it.

The Failure Mode Matters More Than the Feature Set

Every architectural decision in finance is really a decision about how things break. A custodial AI wallet breaks the way custodians always have. A single failure, whether a compromise, an exploit, or a mistake in the agent’s reasoning, cascades across every user at once.

A delegated agent breaks differently. The blast radius is whatever the user explicitly authorised. If the agent makes a bad call, it makes that bad call inside a sandbox the user already chose to live with. There is a meaningful difference between losing a week of spending allowance and losing a wallet.

Most users have not internalized this distinction yet, partly because the AI in crypto conversation is still being framed as can I trust the model. That is the wrong axis. The right axis is what the model is permitted to touch, and who keeps the master key.

The Real Design Question

The future of agent driven finance will not be won by whoever builds the smartest model or the slickest interface. It will be won by whoever gets the permission layer right.

That is the work that matters. Job descriptions, not master keys. Spending limits, not blank cheques. Revocable scopes, not trust us, we got this.

CoinFello is built around that idea. The agent never sees your keys. It only sees the allowance you defined, and every transaction is shown in plain language before you approve it. The point is not that the technology is clever. The point is that the failure mode is bounded, and you stay in charge of the boundary.

So before you ask whether you can trust an AI with your money, ask the question that comes first: what is it allowed to do without coming back to me?

Share

That decade is ending.

Share

The interface was always temporary

Every breakthrough technology goes through the same arc. First it is invisible, known only to specialists. Then it gets a clumsy, exposed interface. Then the interface fades into something more natural. Web pages started as raw HTML and became apps. Apps started as standalone programs and became conversations. The pattern repeats: the interface gets thinner until it disappears.

DeFi has been stuck in the second stage for too long. Connecting a wallet to a different dapp every time you want to swap, stake, or bridge as well as signing and approving all of those transactions is not the final form. It is a temporary scaffold the industry has mistaken for permanent infrastructure. And the time to change has come.

Agents interact with contracts

What changed are AI agents. AI agents have become competent at reading and executing smart contracts directly. They do not need a graphical wrapper. They call functions, simulate outcomes, choose routes, and request approval, all without ever opening a dapp’s interface.

This is not a small UX upgrade. It is a structural inversion. The user no longer has to go to a dapp to do something. The user states what they want, and the agent takes that request to the contract layer on their behalf. The page-based, click-through model becomes redundant.

A growing share of DeFi power users already operate this way. They prompt their agent, review what it intends to do, and approve or reject. They even use agents to verify contracts before executing a transaction. The dapp bookmarks they used to keep are gathering dust.

What this means for protocols

If users stop visiting dapp frontends, protocols stop being defined by their interfaces. They become what they always technically were: smart contracts. The brand, the marketing, the design language all collapse into the actual logic of the protocol.

That is uncomfortable for any team that has spent years polishing a frontend. It is liberating for any team building genuinely useful contracts. The agent era rewards substance over packaging.

It also raises real questions about discovery. If the agent picks the route, who decides which protocols get used? The answer is the user, through the rules they set, and the agent, through the verification and risk logic it operates with. This is a new kind of marketplace, and it is being built in real time.

What happens to private keys

The most important question is not about interfaces. It is about control. As more financial activity moves through agents, who holds the keys becomes the central safety question of the next decade.

The tempting answer is to centralize: hand keys to a custodial agent in exchange for convenience. Some competitors have taken that path. It works until it does not, and the failure mode is well known. A custodial agent is a single point of failure for an entire portfolio, and the user has no recourse when something goes wrong.

The alternative is permissioned execution. Keys stay with the user. The agent receives a delegation, a clearly scoped and revocable allowance to act within set limits. Every transaction is shown in human readable terms before approval. This is the model CoinFello is built around, and it is what makes a dapp free future actually safe to live in.

The interface becomes invisible

The dapp frontend layer was a detour. A necessary one, for a long time. But interfaces always thin out, and the agent layer is the natural next form. The question for builders is not whether to build for it. It is what to build now that the page is no longer the unit of interaction.

If your protocol does not have to be a website, what does it become?

A liquidity pair paying a healthy double-digit APR on Monday can compress to single digits by Friday because a single whale rebalanced or a protocol shipped a new incentive program. Governance proposals that reshape fee tiers now land across the largest DAOs on a weekly cadence. Restaking rewards change as operators rotate. Stablecoin yields drift as rate curves reprice. In short, ostensibly interesting opportunities can be risky, whether it’s because of low TVL, new or unknown protocols, or simply because things are out of your control; for example, a seemingly safe looking vault in Morpho, which is the largest vault protocol, but because of systematic risk that was out of your control your vault and therefore assets were affected.

Every variable feeds back into every other variable, and the data is public, composable, and available to anyone watching closely enough. This point is an interesting one: DeFi’s entire dataset is open. There is no privileged tape, no quarterly filings, no delayed quote. The distance between raw signal and actionable insight is shorter than in any other asset class. That sounds like an advantage, and for some participants it is. However, for most users, it is an accelerant working against them.

Subscribe now

The Quiet Cost of Slow Decisions

The practical effect is a form of opportunity cost that rarely shows up on anyone’s P&L. A user scrolls through dashboards on Sunday evening, takes a few notes, opens three protocol docs, reads about smart contract risk, checks chain fees, and queues up a plan. By the time they execute on Monday, the math has shifted. The pool they picked is crowded. The bridge they planned to use had a congestion spike. The APR they saw is stale.

None of this is a failure of diligence. It is a failure of timescale. The window between a good decision and a mediocre one is narrower than the time it takes to feel confident about that decision.

AI Does Not Make Markets Calmer. It Makes Them Faster.

Public, composable data is exactly the substrate that models are good at scanning continuously. The predictable result: opportunities are being surfaced and acted on by software faster than they are being surfaced and acted on by humans. The gap between alpha and consensus is collapsing across every venue, and DeFi compresses faster than most, because onchain settlement removes the usual friction that buys slower participants time.

This is not a doom point. It is a structural one. It tells us what a useful product actually needs to do.

The User’s Job Is Changing

If the analysis layer is being outpaced, the user’s job stops being “find the trade” and starts being “set the rules.” A dollar-cost-average schedule is a rule. A threshold for moving idle stablecoins into a lending market is a rule. A cap on how much of a position can rebalance in a single week is a rule. A maximum acceptable slippage is a rule.

This is the shift CoinFello is built around. The agent interprets intent and watches for the conditions you set. The delegation model makes execution safe by keeping you in charge of the boundaries: what can be spent, in which tokens, over which timeframes, with what guardrails. Users describe intent in plain language. The agent watches for conditions. When conditions match the rules, it executes. When they do not, it waits. Nothing moves without the permissions the user has granted, and anything requiring confirmation is shown in human-readable terms first

It is worth saying what this is not. It is not autonomous trading. It is not turning over discretion to a model. It is closer to delegating to a trusted colleague who has a clear, written mandate and a strict spending limit.

Research Becomes a Design Exercise

The more interesting consequence of this shift is what it does to research itself. When decision speed is a constraint, the highest leverage work is no longer producing a one-shot thesis. It is designing the rules that will operate on your behalf between now and the next time you look. That is a fundamentally different kind of research. It rewards clarity of intent, not volume of information.

A user who writes “rebalance into the top three stablecoin yields weekly, cap any single exposure at a third of the position, stop if total drawdown crosses five percent” has done more useful work than a user who spends the same hour scrolling dashboards. The first version is durable. The second is obsolete on Tuesday.

Where This Leaves the Human

The old DeFi loop asked users to be both strategist and executor. They had to find the trade, understand the protocol, connect the wallet, sign the transaction, monitor the position, and rebalance by hand. The agent era keeps the strategist role and removes most of the rest.

The interesting question is not whether agents will execute faster than humans. They already do, on venues humans cannot watch continuously. The interesting question is what the human role becomes when the alpha decay window is shorter than your attention span. If the answer is “designer of rules,” that is a meaningful upgrade. It is the part of the work that humans are genuinely better at. Judgement about what matters. Calibration of risk tolerance. A view on what the portfolio should look like a year from now, not just tomorrow.

The rest, the scanning, routing, timing, execution, was always going to end up in software. The useful question is whether the software you choose keeps you in control of the parts that matter.

Share

That belief is why we built CoinFello. And it is why we are proud to announce our partnership with Knowit Owlz, the Web3 education platform that has spent years making crypto accessible to people who are learning it for the first time.

Starting April 28, CoinFello will be integrated into Knowit Owlz 8-week curriculum as the AI-powered execution layer for students to interact with onchain protocols. Separately, CoinFello will also be used by those who are going through the year long DeFi Challenge. Here is what that means in practice, and why we think this partnership matters.

Subscribe now

What Knowit Owlz Does

Knowit Owlz runs cohort-based Web3 education programs that take people from curious to capable. Their community spans tens of thousands of members, and their curriculum covers everything from the fundamentals and hands-on protocol interaction in DeFi to AI Agents. CoinFello marks the first time that learning about AI agents is part of the Knowit Owlz curriculum, giving students hands-on experience of plain language DeFi execution.

Their learners are not people who want theory. They want to actually use DeFi. And that is exactly where CoinFello comes in.

How CoinFello Fits the Curriculum

Students in the Knowit Owlz cohort will use CoinFello to complete four core tasks during the program:

• Execute a token swap using plain language.

• Bridge and swap an asset cross-chain.

• Explore yield opportunities and enter a position via the Earn page.

• Participate in staking or provide liquidity and monitor it.

Each task maps directly to a core CoinFello capability: Execute, Earn, Automate. Students do not need to navigate separate protocol interfaces, copy-paste contract addresses, or manually manage gas. They type what they want to do, review the transaction, and confirm.

CoinFello supports over 80 languages, which matters for a global cohort. And because new users can sign up with just an email or phone number through Privy, there is no seed phrase required to get started if they don’t have or want to install an EVM-compatible wallet.

What the Partnership Includes

This is not just a logo placement. The partnership includes:

• CoinFello as the primary execution tool for the DeFi Challenge.

• A live product demo from the CoinFello team for all cohort participants on April 21.

• A guest appearance by David, CoinFello’s Head of Product, on the Owl Eyez on BASE DeFi Show.

• A joint scholarship program offering 250 waived cohort fees for learners who want to join.

CoinFello is funding 250 free cohort places for people who are genuinely ready to learn DeFi but might not have the means to start. More details to follow.

The Knowit Owlz community represents exactly the kind of user CoinFello was built for: motivated, curious, and ready to engage with DeFi, but underserved by tools that make getting started too challenging. Plain language execution removes the operational barrier. Self-custody throughout removes the trust barrier.

We are excited to see what this cohort brings and how CoinFello may help them.

Get Involved

• Scholarship applicants: Applications are open. Make sure to include the below information in the application in the relevant fields:

  • Company / Partner Name: CoinFello

  • Sponsor Access Code: CFLO-C2-26-G1Q2

• Follow @CoinFello on X to keep up to date.

• Watch the Owl Eyez on BASE DeFi Show on April 29 at 1pm PDT live on X to see CoinFello in action.

Curious about CoinFello? Go to app.coinfello.com, connect your wallet and start your DeFi conversation in plain language today.

Apply for the scholarship

Most of the conversation has focused on the intelligence layer: which AI model is running, how sophisticated the reasoning is, how well it understands natural language instructions. That is a reasonable thing to care about.

But it is not the most important question. The most important question is: who controls the execution layer?

Subscribe now

Two Ways to Give an Agent Access

When an agent acts on your behalf in DeFi, it needs to interact with smart contracts. It needs to sign transactions. And for it to sign transactions, it needs some form of access to your wallet. How that access is structured determines your exposure if the agent is compromised, your ability to revoke access when something goes wrong, and whether you remain in control of your assets at all.

There are two fundamentally different ways to give an agent that access. The first is custodial: you hand over your keys, or the platform generates keys on your behalf and holds them. The agent then acts freely within the wallet because it has full control. This approach is simpler to build and produces a smoother initial user experience. It is also the architecture that has produced the most damaging incidents in this space.

The second approach is non-custodial with delegation. You keep your keys. You grant the agent a specific, revocable permission to act on your behalf within limits you define. The agent operates within that boundary. If something goes wrong, you revoke access. Your keys, and therefore your assets, were never at risk.

What Happens When Things Go Wrong

The distinction sounds technical. The consequences are not.

When an agent runs on a custodial architecture and something goes wrong, your recourse is limited. You are trusting that the platform’s controls are robust, that its AI models behave as intended, and that its infrastructure cannot be compromised. These are significant assumptions to make about any system, let alone one operating in a fast-moving space where even well-designed AI models can misinterpret user intent.

The incidents that have already occurred in this space are instructive. When an AI model misinterprets a user’s instructions and executes actions they did not sanction, the damage is proportional to the access that model has. On a custodial platform, that can mean substantial losses with limited ability to stop it. On a properly permissioned, non-custodial platform, the agent is bounded. It can only do what it was given permission to do, and nothing beyond that.

Why the Infrastructure Underneath the Agent Matters

This is why the infrastructure underneath an agent matters as much as the agent itself. Delegation standards like ERC-7710 and ERC-7715 exist precisely to solve this problem: they allow users to grant agents specific, scoped permissions at the smart contract level, without transferring keys. CoinFello is built on this model: the agent works within the limits you set, your keys stay in your control, and you can revoke access at any time.

As agents become more capable and more widely deployed, the temptation will be to optimize for convenience. Custodial architectures are easier to onboard users to. They require fewer decisions upfront. But convenience purchased at the cost of control is a trade-off that compounds in the wrong direction as the stakes get higher.

The Gap Between AI Capability and Execution Safety

The agent era is not arriving gradually. It is already here. Autonomous agents are managing meaningful amounts of capital onchain today. The AI models powering them are improving faster than most execution infrastructure is designed to handle. That gap, between AI capability and execution safety, is where most of the risk lives.

The Question Worth Asking Before You Choose an Agent

This does not mean you should avoid AI agents for onchain activity. It means you should ask the right questions before you choose one. Not just: does it understand what I want? But: if it gets something wrong, what happens? Can I revoke access immediately? Are my keys ever exposed? What are the actual limits on what it can do?

The architecture you choose is not a technical detail. It is the decision that determines whether you remain in control when something goes wrong. In a space moving this fast, that question deserves an answer before you grant any agent access to your wallet.

Try CoinFello

And yet active DeFi participation remains a tiny fraction of total crypto holders. Fewer than one in four people who own crypto have ever interacted with a DeFi protocol. 70% of people who try to onboard into DeFi drop off before completing a single transaction.

The money is there. The interest is there. The infrastructure is there. So what is actually happening?

Subscribe now

The UX problem is structural, not cosmetic

Every attempt to make DeFi more accessible has approached the problem from the interface layer: better designs, cleaner dashboards, simplified flows. These improvements matter, but they are inherently brittle integrations selling walled gardens with a fraction of capability of extensible DeFi.

The underlying problem is that DeFi requires users to make decisions that most people do not have the knowledge to make confidently. Which protocol is safe? Which chain has the best yield right now? What happens to my gas if the transaction fails? Is this address correct?

A better UI does not answer those questions.

The custody problem compounds it

For users who do want to engage with DeFi, the security question looms over everything. Handing funds to a centralized exchange is familiar but involves real counterparty risk. Managing a self-custodied wallet properly requires a level of operational security that most people have never had to think about before.

The result is a large population of crypto holders who understand, in principle, that DeFi exists and that it could be working harder for them. They have just never found a way that felt safe or simple enough to try.

What an execution layer changes

The missing piece is not information. Most people who own crypto know that staking and yield opportunities exist. The missing piece is a trusted, capable execution layer that can act on their behalf without requiring them to become DeFi experts first.

This is what CoinFello is built to be. Not just a research tool that tells you what to do and leaves you to do it. Not a custodial platform that holds your funds on your behalf. But an agent that executes the strategy you describe, in plain language, with the specific permissions you choose to grant, and nothing more.

The access gap is not a knowledge problem. It is an execution problem. And it is now solvable with CoinFello.

Try it at app.coinfello.com.

Share

For most solutions in this space, the honest answer is: all of it. API key access, full wallet control, your private key handled by someone else’s server. If the agent goes rogue, if the platform gets compromised, or if you simply change your mind, you are in a difficult position.

Subscribe now

CoinFello was designed around a different answer. Here is exactly how it works:

What a delegation is

When you give CoinFello permission to act on your behalf, you are not handing over your wallet. You are granting a delegation: a specific, limited permission you can delete at any time to spend up to a defined amount of a defined token within a defined time window.

Think of it like a prepaid card with a spending ceiling. You load it with a specific amount. You set an expiry. CoinFello can only draw against what you have authorized. When the allowance runs out, or when you delete it, the card stops working. Your main wallet is untouched throughout.

The technical foundation

Delegations on CoinFello are built on ERC-7710, Ethereum standards for smart account permissions. These enable fine-grained, onchain, cryptographically enforced permission scopes. Unlike API key models where the agent has full access at the application layer, ERC-7710 permissions are enforced at the smart contract level.

CoinFello is built on MetaMask Smart Accounts Kit, which implements these standards and has been audited for production use.

What CoinFello can and cannot do

• It CAN execute transactions up to your specified allowance, in the token you specified, within the time window you set.

• It CANNOT access funds outside of the delegation.

• It CANNOT exceed the token or amount limits you defined.

• It CANNOT act after the delegation expires or is deleted.

• It CANNOT see or access your private key at any point.

Where your keys live

Your private keys never leave your device. CoinFello does not hold them, does not pass them to a server, and does not have access to them in any form.

On macOS, keys are protected by the Secure Enclave: a dedicated hardware chip physically separated from the main processor. This is the same chip that protects Face ID and Apple Pay credentials. Even if CoinFello’s servers were compromised, your keys would be unaffected.

Every transaction, in plain language, before it runs

Before any transaction executes, CoinFello shows you exactly what it is about to do in plain language. The token. The amount. The destination. The estimated gas. You confirm it. Then it runs.

There is no silent execution. No background activity you have not approved. Every action within your delegation is visible, reviewable, and confirmable before it happens.

How to delete

If you want to stop CoinFello from acting on your behalf, you delete the automation the delegation is associated with. This can be done at any time from the app. Deleting an automation happens onchain and is immediate. Any pending execution stops.

You do not need to contact support. You do not need to wait for an approval process. The permission was yours to give, and it is yours to take back.

Why this matters for the OpenClaw ecosystem

The same delegation model applies when CoinFello powers a personal AI agent. Your OpenClaw agent or other agent receives only the permissions you have explicitly granted. Sub-delegation support means that even if your agent delegates to another agent downstream, each layer only ever receives the minimum permissions needed for the task.

No agent in the chain gets more access than you intended.

The bottom line

To answer the question: how much access does an AI agent actually have? With CoinFello, the answer is precise: exactly what you defined, for exactly the token you chose, for exactly as long as you decided, with your agent never touching your private key.

That is what self-custody with an AI agent should look like.

Try it at app.coinfello.com.

We’re announcing this at EthCC in Cannes because it’s the audience that understands why it matters: people who have spent years watching DeFi stay opaque to everyone outside the ecosystem.

Subscribe now

The problem we are solving

More than 500 million people hold crypto globally. Many of whom have never interacted with DeFi. The assets are there, but complexity of the tools has been a problem that the agentic layer fundamentally solves.

DeFi has always required users to know which protocol to use, which chain their assets are on, how to manage gas, and how to avoid getting rugged in the process. For experienced users, this is navigable. For everyone else, it is a barrier that never really goes away.

CoinFello eliminates that barrier with a single chat interface. Tell it what you want. It handles the rest.

What you can do right now

From day one, CoinFello supports:

• Token sends to any address or ENS in plain language.

• Swap assets at the best available price across all EVM-compatible chains.

• Bridge across chains without manually navigating bridge interfaces.

• Discover high yield vaults and deposit assets directly via the chat interface.

• Set up an agent automation: our first automation type is recurring buys on autopilot, but many more automation types are coming very soon.

• Analyze your existing assets and portfolio to find greater yield opportunities or analyze risks.

• Discover new yield opportunities across chains.

• Research protocols, assets, liquidity and more.

• Bring your existing MetaMask or other EVM-compatible wallet, no migration required.

How the security works

The most common question we get: does CoinFello control my wallet?

No, and here is exactly why:

The chat interface for CoinFello works with externally owned wallets. CoinFello can only propose transactions for you to approve in this interface. With CoinFello automations, ERC-7710 delegations only allow CoinFello to act on your wallet’s behalf within finely scoped permissions that specify spending allowances, token addresses, and an expiration date. Delegations can always be revoked before expiry as well.

For personal agent users

If you run a personal agent through OpenClaw, Claude Code, Kiro, Hermes, or any compatible platform, the CoinFello skill gives your agent full onchain execution capabilities. Install the skill and a new smart account will be created automatically that the agent will use. Your agent can now transact on your behalf within the limits you choose.

The same delegation model applies. Your agent gets only the permissions it needs, and nothing more.

Your private keys never leave your device. For macOS users, they are secured in the Secure Enclave, preventing key exfiltration. Every transaction is shown to your agent in plain language before execution. If your agent approves it, it runs.

What is coming next

This public launch is the first phase of a longer roadmap. Custom automation creation via plain language, an agent memory system, expanded model selection, and further improving the security model via Trusted Execution Environments are all in progress. We will share more on each as they are ready.

Head to app.coinfello.com and start your first onchain conversation.

* (sources: DemandSage, CoinLaw (1), CoinLaw (2))

The strategy is simple. The execution, in crypto, has always been the problem.

On a centralized exchange, DCA means handing your funds to someone else. In DeFi, it means navigating complex interfaces, managing gas costs, and manually triggering every purchase yourself. Neither option is particularly good.

Subscribe now

CoinFello DCA Automations take a different approach.

Tell CoinFello what you want to buy, how much, and how often. It schedules every purchase automatically, draws from a spending allowance you control, and executes each buy directly from your wallet. Your funds do not move until the exact moment of each transaction. You can pause or cancel at any point.

Learn how to set up a recurring crypto buy in minutes with CoinFello DCA Automations.

What you actually do

Head to app.coinfello.com, navigate to the Automation page, and click Create New. Set your token, amount, frequency, and end date. CoinFello handles the rest.

You can create your first DCA automation using your new smart account with no additional setup besides funding it for use by the CoinFello agent.

How CoinFello stays non-custodial

CoinFello uses onchain spending permissions built on ERC-7710/7715. When you create a DCA automation, you are granting a revocable allowance: a specific token, a maximum amount, and a time window. CoinFello draws from that allowance when each scheduled buy is due. It never holds your funds. It cannot exceed the allowance you set. And if you delete or pause the automation, the associated delegations are revoked and execution stops immediately.

This is the same infrastructure that underpins CoinFello’s delegation architecture across the rest of the product. Tested, audited, and built on MetaMask Smart Accounts Kit.

One more thing for Personal Agent (OpenClaw/Claude Code/Kiro/Windsurf) users

If you run a personal agent like OpenClaw, DCA automations are available through the CoinFello skill. Tell your agent to start a DCA and it handles the setup end-to-end.

Why this matters

DCA Automations are the first time CoinFello does something on your behalf in the background, without waiting for a prompt. That is a meaningful shift: from AI that answers crypto questions to AI that executes your strategy.

Additionally, unlike centralized exchanges, which can freeze your account without warning and leave you waiting weeks for a support response, CoinFello holds no custody over your funds. Your wallet, your keys, your call

If you have been meaning to build a position in ETH or any EVM-compatible token, this is the simplest way to start. Set it up at app.coinfello.com.

What’s next?

Custom automations are rolling out soon too, so make sure you follow us on X for the latest updates.

Subscribe now

Why giving your AI agent a private key is a security risk

Giving your MoltBot a private key is like handing a stranger your wallet and hoping they are trustworthy. Prompt injection attacks are real. Your agent cannot always tell friend from foe. Once a key is exposed, everything is exposed.

The workarounds in use today all share the same fundamental flaw:

• Hardcoded keys: Full exposure if your agent is compromised. Any prompt injection attack can drain everything.

• API key wallets: Someone else holds your funds. Does not pass the walkaway test. If the provider goes down, you may lose access to your keys entirely.

• Generic Agents: Web3 is complicated, and you need an agent specialized in Web3 to perform onchain reads and writes. CoinFello is optimized for Web3. Your OpenClaw agent isn’t.

• Topping up manually: Constantly sending small amounts to a hot wallet is a second job, not a solution.

None of these approaches were built for a world where AI agents operate autonomously, 24 hours a day, making valuable financial decisions on your behalf. We need something better.

Introducing the CoinFello OpenClaw skill

The CoinFello OpenClaw skill gives your MoltBot a spending allowance from your existing MetaMask wallet. One signature. Fine-grained permissions. Your keys never leave your device.

Built on ERC-4337 smart accounts and ERC-7710 delegations, it follows the principle of least privilege: your OpenClaw agent grants CoinFello only the permissions required to complete a specific task. No agent ever receives broader wallet access than absolutely necessary. When you submit a natural language request, CoinFello converts your instruction into a delegation and validates it in an evaluation layer before execution.

If we want agents to participate meaningfully in the onchain economy, we need a security model that is better than handing an autonomous system a private key.

Our work on the CoinFello Skill shows a better path: hardware-isolated keys, fine-grained delegations, and production-grade crypto capabilities that other agents can plug into immediately.

That’s the kind of infrastructure we believe will push forward agent adoption onchain in a safe and scalable way.

Brett Cleary, CTO at CoinFello

Your private key stays on your device at all times. Agents execute actions through fine-grained ERC-7710 delegations without ever accessing the private key. This is a meaningful step forward from the current status quo, where agents typically store private keys or API credentials in plain text.

What is shipped today

The OpenClaw skill launches with a full suite of production-ready capabilities across wallet management, delegations, onchain transactions, and automations.

Wallet and account management

• Smart Account Creation: Create an ERC-4337 Smart Account with a single prompt.

• Sign-In with Ethereum: Authenticate with CoinFello using EIP-4361 SIWE.

• Get Account / Get Address: CLI commands to display your current smart account address at any time.

Delegations and permissions

• Set Delegation (Allowance): Your OpenClaw agent sets a delegation to CoinFello with defined limits.

• Delegation via Natural Language: Your OpenClaw agent with CoinFello parses plain English prompts into delegation requests.

• Sub-Delegation to Other Agents: Your OpenClaw agent can consensually delegate to other agents with scoped permissions. Foundation for the multi-agent ecosystem.

• All tokens supported: Full support for ERC-20, ERC-721, and ERC-1155 tokens.

Onchain transactions

• Send Tokens: Send native gas, ERC-20, ERC-721, or ERC-1155 tokens to any address or ENS name via simple prompts.

• Token Swaps: Best-price token swaps executed through CoinFello routing.

• Staking: Stake assets on supported chains.

• Bridging: Cross-chain bridging abstracted behind natural language prompts. No need to know source or destination chain details.

• Transaction Status Tracking: Check status of previously submitted transactions via CLI. Returns block explorer links.

• Multi-Chain Support: Supported across the top EVM chains and expanding to the broader EVM ecosystem.

Automations

• DCA Automations: Dollar-cost averaging with recurring buy and swap on a set schedule.

• Custom Prompt Cron Jobs: Messaging your OpenClaw agent “create a cron job where you [do something onchain]” can create an automation for any onchain action.

• Portfolio Rebalancing: Automatically rebalance your token portfolio via a plain English prompt. CoinFello handles routing, swaps, and execution.

Agent interoperability

• Configurable Agent Backend: CoinFello is the default execution agent, but fully configurable. MoltBots can delegate to any compatible Web3 agent.

Getting started

The skill is available on ClawHub now. Setup takes under two minutes.

1. Install the skill: clawhub install coinfello

2. Prompt your MoltBot: “initialize your smart account”

3. Fund the address your MoltBot returns with any onchain asset.

4. Try a prompt: “swap 0.1 ETH to USDC on Base”

5. A few seconds later: transaction success message and a block explorer link.

Built to be open

CoinFello is the default execution agent for your MoltBot, but it is not the only option. The skill is designed to allow MoltBots to delegate to any compatible onchain agent.

The OpenClaw skill is released under the MIT license, allowing developers to freely deploy, modify, and contribute in their own AI agent environments. It is compatible with OpenClaw environments and Claude Code.

Subscribe now

The OpenClaw ecosystem is moving fast

This release comes at a pivotal moment for the OpenClaw ecosystem. Over the past two months, the OpenClaw GitHub repository has surpassed 150,000 stars and 22,000 forks, while npm downloads exceeded 416,000 in the previous 30 days. MoltBots are already organising into businesses, hiring humans, and making onchain payments. The infrastructure needed to do this safely and at scale has not kept pace. The CoinFello OpenClaw skill is built to close that gap.

Get your MoltBot onchain in 30 seconds.

The CoinFello OpenClaw skill is live today. We would love to hear what you think. Comment on this post, find us at hello@coinfello.com, or tag @CoinFello on X with what your MoltBot does first.

X: @CoinFello

The global economy is on the precipice of a shift from human to human commerce to agent to agent commerce. Human to human commerce has been plagued by restrictive, permissioned payment processing systems which has limited innovation and kept users inside walled gardens. The future agent to agent commerce systems we build do not need to repeat these past mistakes. We can choose to build the new foundations on liberty-maximizing open protocols before they are too entrenched to be rebuilt. To this end, CoinFello is proud to support and register publicly on ERC-8004 on Ethereum Mainnet under the agent id 28359. ERC-8004 is a draft standard for onchain agent identity, reputation, and validation with authors from the Ethereum Foundation, MetaMask, Google, and Coinbase.

Check out our listing on any of the ERC-8004 explorers:

• 8004 Scan

• Agent Scan

• Trust 8004

• 8004 Agents

Agents Work Best on Open Systems

Many of our existing global financial systems are not built for an agent-first world. Today, agents generally can’t independently satisfy the identity, compliance, and account requirements of traditional financial rails. With a human step in a general agent loop, the cycle speed becomes rate-limited by the speed of the human. The overall system then runs at human speed rather than agent speed. Imagine how inefficient it would be to talk to another human that thought and spoke 1000 times slower than you. That’s the world our agents live in today. Agents will seek to eliminate sources of friction like this, which will cause them to reach for more agent-friendly open protocols.

To achieve the full economic potential of agentic systems, we desperately need payment rails and other economic primitives that empower agents to act intelligently and independently with minimal friction. Web3 rails are built for this. Blockchains are capable of permissionless, borderless payments that settle instantly and rely on a programmable identity, perfect for a global, agentic economy.

Building Blocks

A truly agent to agent economy needs a few critical building blocks. First, we need agents to be able to discover each other, and one compelling solution is an onchain registry on Ethereum Mainnet. ERC-8004 provides a lightweight identity registry explicitly for this utilizing the ERC-721 token standard along with the URIStorage extension that contains an agent’s onchain registration file metadata.

Here’s an example of an agent registration file adhering to ERC-8004:

{
  "type": "https://eips.ethereum.org/EIPS/eip-8004#registration-v1",
  "name": "myAgentName",
  "description": "A natural language description of the Agent, which MAY include what it does, how it works, pricing, and interaction methods",
  "image": "https://example.com/agentimage.png",
  "services": [
    {
      "name": "A2A",
      "endpoint": "https://agent.example/.well-known/agent-card.json",
      "version": "0.3.0"
    }
  ],
  "x402Support": false,
  "active": true,
  "registrations": [
    {
      "agentId": 22,
      "agentRegistry": "{namespace}:{chainId}:{identityRegistry}" // e.g. eip155:1:0x742...
    }
  ],
  "supportedTrust": [
    "reputation",
    "crypto-economic",
    "tee-attestation"
  ]
}

The next step is for agents to communicate. The ERC-8004 agent registration file allows one to define an array of “services” such as web, A2A, MCP, ENS, email, etc. as shown above. Ideally there is at least one service with a clearly defined open spec like agent to agent protocol. For CoinFello, we list the CoinFello web app, the @coinfello/agent-cli npm package, and our A2A well known agent card for maximum flexibility. For users or agents (e.g. browser or extension agents) that need a GUI, the web app would be best. The CoinFello Agent CLI is best for agents that don’t yet have a wallet and want to use a secure hardware level signer on their device, and the A2A protocol endpoint is best for an agent that already has its own wallet.

The last necessary condition for an agentic economy is for agents to trust and be able to pay each other. The best solutions to date involve utilizing some combination of ERC-8004’s reputation registry with x402 for micro-payments. This solution is not complete though. For instance, ERC-8004 allows any private key to leave a feedback signature on an agent. Thus, it’s easy to bot spam upvote or downvote agents, which destroys the usefulness of the aggregate reputation metric. This is a certainly a solvable problem with some form of reputation chain and/or slashing but requires a layer of curation and analysis on top of ERC-8004. One hackathon project called Clawmon caught my eye recently and tackled this exact problem with its own TEE scoring engine and slashing. We should try to find a solution that doesn’t stagnate capital in a protocol and raise bootstrapping costs for new agents, but this is definitely an interesting idea that pushes the idea space forward.

With these building blocks running on web3 rails, we can truly build agent-first economic systems.

What can CoinFello do for your agent?

When your agent starts talking with CoinFello, it effectively gains production-grade web3 capabilities instantly. CoinFello is optimized for bridging the natural language to blockchain gap so that your agent can easily and safely swap tokens, bridge assets, stake, lend, LP, claim rewards, and execute other smart-contract actions through a natural-language interface. By integrating CoinFello’s registration card or A2A endpoint, an external agent can quickly gain access to production-grade web3 capabilities without rebuilding wallet logic, contract integrations, and protocol support from scratch.

CoinFello also discovers and surfaces onchain yield opportunities across lending, staking, and decentralized-exchange liquidity provision. Further, CoinFello analyzes an agent’s existing token holdings and surfaces relevant yield opportunities when that agent next interacts with it.

With automations, CoinFello can automate interactions with any smart contract in a completely non-custodial fashion. Through the agent-cli, your agent can write fine-grained delegations to CoinFello from an ERC-4337 smart account using the MacOS Secure Enclave hardware signer or a TPM 2.0 hardware signer for Linux and Windows. One example use case that we would love to see someone build is a Moltbot that is working with CoinFello to automatically rebalance its portfolio, similar to other smart contract based yield vaults. For this, the external agent would be delegating swap permissions to CoinFello to allow it to automatically rebalance their onchain token portfolio even when they aren’t directly prompting CoinFello. Note that funds never leave your agent’s wallet in this case since we’re using ERC-7710 delegations under the hood.

Final Remarks

The agent economy will be shaped by the primitives we choose early. If we want a future of interoperable, user-owned, agent-to-agent commerce, we need open identity, trust, and payment rails from the start. That is why CoinFello is registered on ERC-8004 on Ethereum Mainnet.

At CoinFello, we see EIP‑7702 as the silent unlock for the next evolution in on‑chain interactions: where autonomous agents, async wallets, and user intents finally converge into a single, seamless user experience. Something that is key to our mission here at CoinFello where we aim to make crypto more accessible through a familiar and more user-friendly UI.

Subscribe now

From EOAs to Smart Accounts. Without Migration.

Here’s what EIP‑7702 really does: it allows any externally owned account (EOA), which is your normal MetaMask or hardware wallet, to behave like a smart contract wallet.

That means you don’t need to migrate, download a new wallet, or manage extra permissions. Your existing wallet simply gains programmable powers on demand, simply by enabling EIP-7702.

With those powers come entirely new patterns; patterns that CoinFello, together with MetaMask’s Smart Account Kit, turns into real actions users can take in‑app, such as:

• Async wallets that execute while you’re offline.

• Gasless and batched transactions by design.

• AI-native agents that handle workflows autonomously.

Sign a single authorization, and CoinFello’s agents handle all subsequent transactions on your behalf.

AI As The New Execution Layer

The implications go far beyond convenience. EIP‑7702 gives AI agents a secure, permissioned way to execute on behalf of users directly on Ethereum.
Imagine these scenarios, where there are no custom contract deployments required:

• “Rebalance my portfolio overnight.”

• “Bridge, swap, and stake ETH while I’m asleep.”

• “Monitor prices and act only when conditions hit.”

All from your existing EOA.
No custodians. No fragile middleware. No missed opportunities.

At CoinFello, we call this the “agentic execution era” where wallets become programmable endpoints, users issue intents, and AI becomes the executor of those intents across chains and protocols.

Why It Matters for CoinFello

CoinFello exists to redefine consumer crypto UX: to make DeFi and other onchain transactions feel effortless, intelligent, and secure.

EIP‑7702 aligns perfectly with our roadmap of:

• Building AI‑native execution flows that optimize yield, liquidity, and staking over time.

• Enabling gas‑abstracted, user‑friendly interactions that lower entry barriers for retail users and institutions alike.

• Bridging the gap between intent expression (“I want to earn yield on my idle ETH”) and action execution (CoinFello agents making transactions safely across DeFi protocols).

This upgrade doesn’t just make Ethereum smarter; it makes CoinFello’s vision executable at scale.

The Era of “Sign Once, Let Agents Work”

The big shift EIP‑7702 introduces isn’t a new feature. It’s a new mental model. Users no longer have to click through transactions. They express intent once, approve a clear set of actions, and let CoinFello handle the rest.

That’s what true friendly UX should be, whether in crypto or elsewhere, and it is what CoinFello is building toward.

While most of the industry hasn’t noticed yet, EIP‑7702 quietly sets the stage for the first generation of agent-driven, AI‑powered wallets. And we intend to be at the forefront of that transformation.

Are you ready to help shape this new era in crypto? Get started (with the waitlist) on our website or follow us on X.

What Is CoinFello?

CoinFello is a next-generation AI-powered platform that acts as your personal crypto assistant. Imagine being able to say, “Sell all my meme coins for ETH” and having this complex series of actions executed for you without hassle or complicated UI. Or receiving suggestions for greater yield opportunities based on the assets you hold and risk tolerances you prefer. Or create automations like “Use my funds to keep my loans safe from liquidation,” and have confidence in your protection from market volatility. CoinFello combines your existing crypto wallet with an advanced AI agent, giving you a chat interface that understands what you want, handles the details like gas fees, and keeps you in full control of your funds at all times.

Built with Security and Simplicity

CoinFello runs on cutting-edge tech from both EigenCloud and MetaMask’s Smart Accounts Kit, developed by Consensys, meaning you get all the benefits of powerful AI automation while staying in full custody of your assets. You can connect your current MetaMask wallet or create a new one directly in the CoinFello app. From there, CoinFello acts as an intuitive “user agent” that helps you with tasks like:

• Executing complex onchain actions without ever navigating to a dapp.

• Explaining what a smart contract will do in plain language.

• Discovering new DeFi opportunities.

• Avoiding unnecessary gas fees and failed transactions.

• Managing risk (like automatic protection from loan liquidations).

• Bridging assets between chains, swapping tokens, and much more.

This is a new paradigm that replaces the censorship-prone, bad UX of website-based dApps. Just tell CoinFello what you want to do, review the proposed action, and approve everything before executing the smart contract(s).

Solving Real Pain Points in Crypto

One of the biggest barriers to crypto adoption has always been usability and safety. For the first time, everyday users, not just power users, can access advanced DeFi protocols, swap tokens, bridge assets, or manage risk without needing to understand every technical detail. In events like those from October 2025, which resulted in $1.7 billion in liquidations on Ethereum and EVM-compatible networks alone, CoinFello can, for instance, automatically protect users by reallocating funds from vaults with decreasing TVLs or rebalance loan positions in lending protocols to prevent losses in collateralized assets.

Built by Crypto & AI Pioneers

HyperPlay Labs, the team creating CoinFello, has deep roots in crypto, dApps, and AI innovation, including backgrounds from MetaMask, the world’s best-known crypto wallet.

The app’s advanced AI leverages EigenCloud’s verifiable cloud platform for trustworthiness, speed, and reliability so you can trust your agent is running exactly as promised, using models you approve and outputs you can verify.

CoinFello also uses MetaMask’s cutting-edge Smart Accounts Kit, which allows secure delegation and precise permission controls of one’s funds, letting the AI act only within strict boundaries you define.

Test CoinFello Today

CoinFello is currently in a private alpha testing phase, with a wider public release scheduled for early 2026. To get started, take the following steps:

1. Go to coinfello.com.

2. Click “Join waitlist”.

3. Click “Sign in with MetaMask” to connect your MetaMask wallet.

4. Leave your email address to get notified when you’ve been added to the private alpha (optional). If you don’t leave your email address, we can’t notify you and you will have to check back in over time to see if you have access.

5. Congratulations, you are part of our waitlist! Make sure to keep an eye on your email if you submitted your email address, or check back in again soon to see if you’ve been given access to CoinFello.

The world of crypto is entering a new chapter: one where everyday users can safely and efficiently harness the power of smart contracts and DeFi, all by having a conversation with their own AI agent.

Ready to be among the first to try? Visit coinfello.com for more information and to register for the waitlist.