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.