Myles O'Neil

In personal news, I’m thrilled to announce that I’ve joined @deltadotnetwork as head of product. Wanted to share a few words on what led to delta and why I joined. I’ve always subscribed to the “fat application” thesis. Users come for the apps, and the winning apps will determine the shape of the underlying infra, not the other way around. During my incredible time at @hi_Reverie, I learned first hand from our work with appchains like @dYdX, @osmosiszone, and @stride_zone, that this comes with tradeoffs. Namely 1) no native distribution to users and 2) huge amounts of interop and dev ops complexity. This is why it appears from the outside that the appchain thesis is struggling today. Enter delta. I joined because this is the first system I’ve seen that can finally break this tradeoff. delta has reimagined what blockchains should look like from the ground up. In this new form factor, apps have full control of execution and ordering similar to appchains, but retain connectivity to a globally shared network of users and assets similar to apps on Solana. I couldn’t be more excited to embark on this new chapter with @spjoleh, @riabhutoria, @iorulezz, @0xFunk and the rest of this amazing team. To learn more about our vision and how things work under the hood, check out our “hello world” post and one page litepaper linked below. And we will be releasing more technical content over the coming months. Fortunately, I’ll continue working with Reverie (@lsukernik, @derek_hsue, @c__bergz and @fededaffina) as both a portco as well as a venture partner. Reverie is a special place that blurs the line between operating and investing, and I’m excited to continue being a part of that exceptional crew. Onwards!

@Henryleemr Appreciate it my friend!

from one of the smartest guys I know in the field on agent verification

Target's new consumer terms state that if your agent buys the wrong thing, YOU are on the hook This highlights the main bottleneck of agentic commerce: liability allocation To solve this, platforms need a policy enforcement layer That's what we've built at @deltadotnetwork

@pumpernikhil @deltadotnetwork @iorulezz For sure but that doesn't help Drift from a brand trust perspective, damage is done

@MylesOneil @deltadotnetwork @iorulezz Or Circle just tries to do something

Not a super popular opinion, but net net, delayed* settlement would be a feature not a bug for most crypto apps *on-demand ideally (yes this is a @deltadotnetwork feature) hack --> tripwire --> rollback --> back to normal s/o @iorulezz

Human reputation systems works because the thing being judged is stable over years. Agents aren’t, so you're left with two bad options: 1) upgrade the model, reputation score becomes ~stale 2) don’t upgrade it, and bet on consumers choosing reputation > performance (bad bet)

Most agentic workflows follow what @eddylazzarin referred to as “AI sandwich” : human director → agent executor → human reviewer. This holds even more when agents automate economic workflows where the cost is of failure is higher. As a result, productivity gains are either capped at human reviewer bandwidth, or worse, agents make errors and lose real money. delta’s role is to automate the verification layer of the sandwich. You attach verifiable settlement constraints (in the form of cryptographic proofs) to any economic workflow, an agent executes it, and delta enforces your rules preventatively, before your money moves. Replace human reviews and counterparty trust with math, and we can raise the ceiling of what can be automated safely at scale.

VI is a good start at trying to address the "intent-matching problem." When a human authorizes a goal + amount and delegates execution to an agent, we currently have no way to assign liability if the agent screws up. VI creates a verifiable paper-trail of constraints authorized, but it's limited by merchant side adoption and a fairly narrow set of constraint types. With stablecoins, we can move goal-based constraint authorization to the spender side. Agent platforms can then spend via any existing rail to execute the user's goal, and reimbursement leg settles if constraints are provably satisfied. This is the only model that can scale autonomous spending safely today, and reflects how stablecoins can also play a valuable role upmarket in the agentic economy (ie not just for micropayments and underserved vendors). Wrote about it here, more to come soon! x.com/spjoleh/status…

mastercard + google launching “verifiable intent” for agentic commerce is an interesting signal web2/tradfi is starting to run into the same problem web3 has been pointing at for years: autonomous systems require verifiable trust infrastructure but this approach is still payments-specific and network-bound, not a universal layer that’s where web3 primitives have the valuable advantage: portable identity, programmable delegation, attestations, and open coordination across domains market may be down, but the need for web3-native trust infrastructure has never been more validated

This framing resonates. It makes payment authorization programmable so agents can only execute transactions that provably match the user’s intent, which is exactly what makes an agent-to-agent economy possible.

When you’re very early stage, your internal POV and strategy changes rapidly as you iterate on direction + wedge etc. It’s extraordinarily valuable to have an external (your investor) that can hear these updates and be the ~first person outside the organization to understand why and how you landed here given all the context they have. And from there, they can 1) provide valuable feedback on how to improve communication of said idea and 2) offer valuable intro’s to potential customers or partners This is ofc non-exhaustive and just based on my experience at delta, where we are extremely lucky to have amazing partners like @hi_Reverie, @FigmentCapital, @dba_crypto, @variantfund

@thebellcurvepod I guess that's where 'venture partners' provide the hot sauce; @MylesOneil great take; what makes a great venture partner for early stage startups in your experience (generalists, ex founders, ex operators or domain specialists)?

Early-stage startups need people who can help navigate the unknown before product-market fit exists. That’s where the right VC can actually matter. “If you can find VCs that help you navigate the unknown rather than just pour gasoline on the fire of something that’s already working, that does matter.” - @MylesOneil

💯 "Stablecoins matter less as settlement rails and more as programmable enforcement. Stablecoins offer an alternative to merchant-side protocols: put authorization logic on the spender side via smart accounts. We can then incorporate semantic intent matching logic with: preventative authorization (don’t spend unless constraints are met), and tamper-proof evidence artifacts for disputes."

In this post, we describe why agent platforms are positioned to be the credit issuers of the future, and how they will do this via their ability to underwrite risk of agent errors. In the near-term, hybrid systems will emerge that leverage 1) stablecoins to support intent-based authorization in addition to 2) traditional card/bank rails to avoid merchant integration bottlenecks. This is what we’re focused on building with partners at @deltadotnetwork. If this sounds compelling, we’d love to chat!

That’s the correct question! Said another way, in what scenarios do you need guardrails that are actually tied to settlement and externally verifiable? Agent providers can and do offer native guardrails, and imo they should be totally sufficient for closed-loop settings or human-approved payments. Guardrails need to be externally verifiable when an agent spends autonomously across trust boundaries. When a human’s prompt leads to an agent spending unattended, we need to restore an independent, machine-checkable way for PSPs/banks/auditors etc to verify that the payment was authorized based on user's goal and policies. Internal controls alone don’t solve that, because the control lives inside one platform while the liability sits across the rest of the stack. delta makes those guardrails externally verifiable and ties them to settlement, so they are enforced before money moves and auditable after the payment settles. The next question that we’re focused on is: how can we anchor guardrails to delta, but extend the guarantees they provide to any external payment rail? We’ve landed on a solution that we’re very excited about, more to share soon!

@MylesOneil cool stuff but don't you think guardrails and access controls are something agent providers could natively offer and embed directly into their services rather than being external?

“Verifiability” has always been a tough sell outside crypto — we’ve broadly failed to translate this property it into a clear commercial “so what” that the rest of the world cares about. However, now that agents can handle any execution task, human verification of AI correctness is the only remaining bottleneck to further productivity gains. And when agents are moving money, 'dangerously-skip-permissions' isn’t an option. Enter: delta's guardrail SDK and settlement layer delta allows you to turn any agent policy or guardrail into a machine-checkable settlement rule. By anchoring agent guardrails to delta, the task of verifying AI correctness can be automated itself, just like execution. 1) Connect your backend, 2) write guardrails, and 3) automate financial workflows, safely.

NEW POD @MikeIppolito_, @MylesOneil, and @0xave discuss: - The Fat Protocol thesis - How to gain distribution today - AI’s impact on distribution - And more! Timestamps 00:00 Introduction 05:07 Market Sentiment 10:32 Hyperliquid Policy Center 13:07 Revisiting the Fat Protocol Thesis 18:26 Canton Ad 19:05 Gaining Distribution Today 35:53 Canton Ad 36:29 How Virality Impacts Distribution 51:23 AI’s Impact on Distribution 01:21:17 Closing Comments

@bennewgen awesome post, thanks for sharing and excited to partner with you guys!

Founder origin story dropping. I grew up in the backstreets of Coney Island. Lived right across a chained-up liquor store where they treated me like family. The single Asian student out of an entire class of Hispanic and Black students. Growing up, I remember distinctly walking to my 1st grade class and thinking "Hey, Elmo shouldn't be smoking that cigarette and what is he doing to Big Bird?"(as I looked down to the phallic symbols scribbled all over to him) I saw how tirelessly my parents worked day and night and knew very young that instead of being a victim, and letting life happen to me - I instead, could happen to it. And with that, I knew I wanted to build something great. My name is Ben, and this is my story. If I was going to be beat, I knew the determinant wasn't going to be lack of hustle. I sold water bottles and Pokemon cards in middle school, tutored affluent students in SAT commuting hours to get there, unknowingly honing my interpersonal and sales skills all the way. I built my first company at 17 by creating a viral Kickstarter company in Japanese kitchen cutlery. Sold the company when I was 21 while at Columbia University and became COO of my best friend's crypto startup building incentive programs for companies like Polkadot, Serotonin and others. We built points programs. Rewards systems. Incentive logic. My whole life was measured in performance metrics and whether I delivered or not. And that is where the real problem hit me in the face. January of las year, our sales team crushed it. Twenty percent month over month growth. I wanted to give them a one percent bonus on revenue if they repeated it the next month. Sounded simple. It took me three hours. I had to calculate revenue manually, compare months, carve money out of banking statements and distribute payouts one by one. By the time I finished, I never wanted to do it again. That was the moment everything clicked. Why is moving money inside a business still this manual? Why can I program software with plain English but not my finances? Why can I not just type: "Send my sales team one percent of top-line revenue if they hit their KPI this month." So I started building Archer. Archer is a programmable neobank where money moves based on what your business actually does. You connect your operational tools. Notion. Linear. Calendly. Intercom. Salesforce. You describe rules in natural language and Archer executes them automatically. Incentives. Payroll. Vendor payouts. Revenue routing. Yield. Purchasing. All programmable. All autonomous. You can move money like you are turning water from cold to hot. You can ask Archer about runway, revenue, or burn. You can automate commerce itself. This is not software that shows you dashboards. This is software that executes. If Elmo was smoking, I was never going to trust the system anyway. I have always built from nothing. And I am all in again and this time with a legendary team of doers and some of the greatest investors in crypto and fintech by my side. We are building the AI programmable stablecoin neobank for businesses - @archer_money

@Randomblock6 @demos_network Expanded on some thoughts here! x.com/MylesOneil/sta…

One we are taking a hard look at @demos_network We have identity nailed between web2 and web3 using our identity aggregation layer. Current thinking is there are layers to verification: - Minor verification - like a receipt, for example this service was given to you at this time and you accessed it. We have our any API oracle infrastructure ready for this, and TLSN for when cryptographic proof is needed - Medium/Trusted Verification - there are systems in Web2 that verify something happened like GitHub for example, again we can record this on chain, and use agents to ratify the work. - Major verification, things like zkml and TEE, at the moment it's expensive so this will be for higher value "quality" checks. Where it's important to do this in a controlled/provable manner. Instinct is low value items probably go in the first 2 buckets higher value are then in the major verification bucket but keen to hear thought on this

Blockchains are the perfect payment rails for agents, but the economic agents need to be able to offer hard, verifiable guarantees in order to be trusted at scale. This is an unsolved problem and very non-trivial. Smart contracts are deterministic, agents are non-deterministic. Blockchains are self-contained (hence the need for oracles), agents need access to the entire internet. Smart contract rules are public, agent rules (guardrails) should be private. My semi-hot take is that I don’t think identity/reputation based solutions are going to be the answer. Would love to hear feedback from folks that are building products and solutions in this space!