building https://xitter.cf/t.co/k9huV9Dd01
Cork
Joined July 2012
- Tweets162
- Following266
- Followers108
- Likes92
Pinned Tweet
Obligatory EIP-8141 v EIP-8130 take, coming full circle on my EIP-7702 interoperability argument.
I went in open-minded and surprised myself by how firmly I landed: 8141 makes interoperable sessions possible. 8130 makes them probable.
peglerweb.services/blog/eip-…
Joe Pegler retweeted
Some pretty cool integrations already happening for the two Pendle Ecosystem vaults on @Morpho:
@beefyfinance: Autocompounds the rewards back into the vault position
@ZyfAI_: Agentic finance where AI allocates USDC across DeFi such as whitelisted Morpho vaults (including Pendle ones) based on yield and risk
Joe Pegler retweeted
Introducing the Zyfai MCP server.
Create a Zyfai account and deposit funds through your AI assistant, without ever opening the dashboard.
You approve the deposit in your wallet. Zyfai handles allocation and rebalancing according to your strategy.
Watch our CTO @Joepegler walk through how it works ↓
Joe Pegler retweeted
Expecting users to keep up with onchain capital management limits who DeFi can serve. Even experienced users have better things to do than check positions every day. Do you really expect web2 users to do the same?
We interviewed 23 Zyfai users about their experience with DeFi.
Three themes kept coming up:
1. Earn yield on any asset without spending hours.
2. Have risks monitored as conditions change.
3. Keep control without managing every position.
This is the work I want Zyfai to take off their hands.
1. Active rebalancing is what drives higher yield than sitting in static vaults, and we prove it every month.
2. Our security agents and quant team monitor risk 24/7 and take actions autonomously instead of just alerting you when you're offline.
3. User-owned accounts and scoped Agent permissions are how we bring back the cypherpunk principles of self-custody and ownership that DeFi gradually gave up by handing control of user capital to curators.
I want people to spend less time managing their capital and feel comfortable letting automation handle the work. We earn users' trust because they can see how the product works.
The foundation we've built is meant to change not only how people earn yield but how they transact and manage capital onchain.
Rome wasn't built in a day.
Joe Pegler retweeted
Tried Wallet V Earn yesterday and honestly didn’t expect it to be this smooth.
You just deposit your stables and these @Zyfai_ agents start working in the background. They continuously look for better risk-adjusted yields across protocols like Morpho, Aave, Fluid and a few others. No need to sit there comparing rates or jumping between apps yourself — the agents handle the rebalancing while you stay in control of your funds.
What stood out for me:
•Setting it up took like a minute
Redeem is basically instant, no long waiting periods
•The APR feels noticeably better than most of the static pools I’ve been using
•It actually monitors risk stuff like liquidity, utilization, APY stability etc instead of just chasing the highest number
•You can see what the agents are doing, which makes the whole thing feel more transparent
Feels like a proper “set it and forget it” feature while still keeping full control. Perfect if you’ve got idle stables sitting around and don’t want them just doing nothing.
If you haven’t tried it yet, I’d say give it a shot. Pretty clean experience overall. You can check their site for more details on how everything works.
@WalletV_io @WalletV_CN
Joe Pegler retweeted
BlackRock calls it the machine economy: agents transacting and managing money onchain.
Zyfai is already a leading agent in this economy, managing over $10M and automating yield allocation and risk monitoring.
Zyllions.
Our latest research paper explores the growing connection between AI and digital assets and explains why broad AI adoption may drive new demand, utility and applications across the digital asset economy. blackrock.com/us/individual/…
Very happy to share that I’ve joined zyf.ai as CTO.
We’re building the infrastructure to make onchain finance simple, safe, and genuinely useful - for people, developers, and AI agents.
There’s a lot to build. I’m excited to get to work.
Joe Pegler retweeted
Really hope this is true because if 8141 gets shipped in its current form it will be a massive failure for Ethereum
Taking 10 years to ship native account abstraction and then choosing a highly complex and overly engineered solution
Hope ACDE wake up and listen to the community
TLDR: Frames (8141) was just SFI-ed, but it was only meant to signal that Ethereum WILL ship AA in Hegota. It does NOT mean that Frames as written, or even the final EIP number, are set in stone.
In the ACDE I was pushing against making the SFI decision now, given that the public pushbacks against Frames and support for 8130 have not been sufficiently addressed. So I felt SFI-ing Frames right at this moment would send the wrong signal that ACD doesn't care about community feedback. However, ACD moderators later clarified that SFI-ing Frames is intended to only signal the ACD's commitment to ship AA, not to Frames's specific content or even the final EIP number.
Therefore, this decision does NOT affect the ongoing collaboration between 8130 and 8141, where we are trying to either:
- Settle on a shared transaction type that is both flexible and future-proof enough for the L1, and is friendly for the scaling needs of L2s.
- Or, if the above is not achievable, then at least ensure that 8130 accounts can be built on top of Frames, so that a 8130 account can share the same address across L1 and L2s, even if it has to use two different transaction types under the hood.
In any case, Ethereum WILL ship native AA in Hegota, because Ethereum L1 and L2s deserve the best UX in Web3. Let's get this done.
Joe Pegler retweeted
The fundamental problem with previous AA attempts is the account model!
Coupling account execution, authentication and authority in one place means that the protocol loses visibility, dependencies must be discovered (via simulation/tracing), layers of mitigations are added.
8141 enshrines that.
The original account model that ethereum shipped with was a decoupled one! The authority was protocol managed and a single intrinsic mapping of secp256k1 to an account. 7702 let accounts set their execution code, which was a good addition.
Execution code in one place (wallet bytecode), authentication in another (secp256k1), authority in another (protocol managed mapping).
8130 just generalizes this mapping system so that its updatable to any contract defined authentication scheme and no longer singular.
Because the model stays decoupled, the transaction type can be declarative. Dependencies can be recognized in the transaction itself.
Mitigations fall away. Customizations can be added on cleanly. Every chain can build what it needs.
8130 enshrines exactly one thing, the authority mapping system, and all of AA falls out.
EIP-7702 made EOAs programmable. It did not make that programmability dependable across wallets.
Part 2 explores ERC-7902’s escape hatch: wallets keep their own defaults but overlap on one audited, session-capable implementation.
Will the incentives allow it?
peglerweb.services/blog/eip-…
7702 succeeded for wallets. Dapp sessions are still waiting.... peglerweb.services/blog/eip-…
The recent discussion (xitter.cf/arik_g/status/20849241…) about whether EIP-7702 has succeeded sent me down a rabbit hole.
I think wallets can reasonably say call it a success. Batching alone is a real win. But dapps still cannot rely on one cross-wallet way to request, scope, redeem and revoke a session over a user’s EOA. The practical fallback is often still an embedded or companion smart account.
I wrote up the gap, the reasonable security choices behind it, and what still needs to converge. Corrections from wallet and AA builders are very welcome:
EIP-7702 went live in may 2025.
Today @FireblocksHQ @coinbase @MetaMask @TrustWallet @dfnsHQ @ambire use it in their products (data via @0xBundleBear) and yet most people in the ecosystem consider it a failed EIP.
Can someone explain this to me?
In 2018 I published a TradingView Pine Script called “Simple profitable trading strategy.”
It got traction, but the real lesson was not the equity curve. It was how a 100x fee-assumption mistake changed the outcome.
I wrote a technical retrospective on backtests vs execution reality: fees, slippage, fills, latency, and automation risk.
peglerweb.services/blog/back…
Available for my next role. Staff/infrastructure engineer focused on low-latency execution systems, SDKs, smart accounts, and production reliability across EVM/Solana. Best fit: serious infra, protocol-adjacent product, execution, devtools, or founding-engineer-style IC work. Remote preferred. Cork, Ireland. DMs open.