Part 3: Protocols of Intelligence

Where Agents Become Allocators

Jul 07, 2025

I’ve joined the Cadenza family of funds as a partner, investing across AI, Web3, liquid strategies, and token events. But this isn’t just about capital deployment. It’s about turning a multidimensional platform into an ecosystem that supports both founders and allocators at the edge of what’s next.

Alongside Max, Kumar, and Harris, I’m helping scale a network that includes Together AI, the former Chief Scientist of Siri, and the original BitMEX team. These aren’t consultants in vests. These are real builders backing real innovation.

At the same time, I’m still building with the platform. Nautilus and Mustaa are deeply aligned with Cadenza’s thesis, and both will grow in step with the ecosystem we’re composing.

This journey unfolds in The Double Helix Thesis. Part 1 shares why I joined and what we’re building. Part 2 explores how code became capital. Part 3 dives into AI agents and intent-based infrastructure. And Part 4 zooms out to map the evolution of venture itself into a multiplayer network.

If you’re a founder building at the frontier, or an allocator looking for signal over noise, we’d love to coordinate.

Smart investors don’t wait for the signal, they browse it. Prepare to explore tactical Web3 strategies at Nautilus.Finance. Stay ahead by following Tom Serres on X.com or LinkedIn.

Capital Got Smart. Now It’s Getting Conscious.

Code became capital. That was Part 2. Capital could finally move at the speed of math instead of the speed of banking bureaucracy. But here’s the catch: movement isn’t enough. You don’t just want your capital flying around like a caffeinated squirrel. You want it to know why it’s moving. And in this next wave, we’re watching something strange and beautiful happen: the logic layer is starting to think for itself.

We’re entering a phase where infrastructure isn’t just programmable. It’s semi-autonomous. Self-driving finance. Logic with preferences. Protocols with opinions. And this shift didn’t come from a Stanford white paper or a regulatory advisory committee meeting with catered sandwiches. It’s happening in live production environments, right now, right under your nose. Agents are already surfacing trends, routing capital, coordinating governance, and occasionally making better decisions than half your board.

This isn’t some sci-fi tangent delivered by a keynote speaker in a silver jacket at a B-tier tech conference. This is Together AI, fine-tuning open inference models while the rest of the world was still arguing about whether ChatGPT could write a decent haiku. This is the same team that helped train the foundational models behind OpenAI, now building side-by-side with us. And just to flex a bit further, we’re talking about the former Chief Scientist of Siri here, helping design on-chain agentic frameworks that don’t just respond to you. They collaborate with you.

Forget the “future of work” panels where everyone nods solemnly and says “co-pilot” 47 times. This is the future doing the work. Not hypothetical agents in a slide deck, but real ones with memory, intent, and execution logic, operating across networks with composable intelligence and programmable autonomy.

In short: the machines are awake, they have wallets, and they’re better at shipping product than your last five hires combined.

Agents as Infrastructure: The Shift Has Begun

Let’s be honest. AI agents aren’t coming. They’re already here, quietly showing up to work while most people are still arguing about whether they’ll take our jobs or just steal our tweets. And the wildest part? They didn’t wait for your approval, your framework, or your roundtable on "Ethical AI Deployment in the Enterprise." They deployed themselves.

In the old model, infrastructure was more like plumbing. Boring, passive, and only exciting when it broke. It didn’t think. It didn’t act. It just sat there, like a well-behaved server rack waiting to be asked politely. But the moment you integrate fine-tuned models with real incentives and mission-aligned objectives, something changes. Infrastructure stops being a venue and starts becoming a co-founder.

In AI-native Web3 systems, agents are already stepping into roles you used to reserve for humans in Patagonia vests. They’re liquidity managers. Governance participants. Strategic operators with keystroke-level memory and latency that makes your fund’s Slack channel look like it’s powered by dial-up.

These agents aren’t running paper simulations. They’re live in production. They move capital across chains based on encoded market signals. They vote in governance forums not with vibes, but with data-weighted preferences. They evaluate protocol strategy with more context, less ego, and none of the “let’s circle back after offsite” nonsense. Your partner meeting looks like a brunch chat. Their meeting is a real-time system optimization loop with chain-state telemetry and dynamic input weighting.

This isn’t a UX update. This is a protocol-level mutation. We’re not tweaking the surface. We’re watching the foundation get recompiled. The operating logic of Web3 is moving from coordination to cognition. From role-based permissioning to intention-based execution.

And if you’re still waiting to draft an AI memo for your board, congrats. You just became the slowest actor in a system where agents don’t need sleep, don’t need a title, and already own keys to the treasury.

Intent-Based Execution: Goodbye Clicks, Hello Coordination

Let’s be honest. If the Web3 UX experience were a dating profile, it would read, “Connect Wallet, Hope for the Best.” Every time you try to do something, you're asked to sign fifteen cryptic messages, decipher gas fees written in Klingon, and pray your transaction doesn’t fail because you sneezed on the confirm button. This is not the future. It’s a hostage negotiation with your own interface.

But the UX layer was never meant to stop there. As intelligent agents mature, we’re evolving beyond the era of endless clicks and into a world where your intent becomes the API. The new interface isn’t a button. It’s your behavior. Or more precisely, the distilled intent your agent has learned to recognize and act on without you even needing to open a new tab.

You don’t initiate a transaction anymore. Your agent sees what you’re trying to do and handles it. You don’t wake up at 3 a.m. to reallocate your yield farming position because some new pool is pumping. Your agent knows your risk tolerance, watches the markets, and rebalances accordingly. You don’t vote in governance because you feel “bullish on vibes.” Your agent runs a weighted analysis of your entire on-chain history, compares proposals to previous upgrades, and casts your vote with more context than a seasoned analyst hopped up on Red Bull and incentives.

This is what intent-based execution actually means. It’s not just streamlining clicks. It’s replacing them entirely. It’s infrastructure that listens, learns, and acts based on your goals, then evolves as those goals change.

And this isn’t a fantasy cooked up by corporate innovation teams with too much whiteboard space. It’s happening now. Together AI is building the infrastructure layer to make agentic coordination real. Not abstract. Not "future of." Real. They are making it composable, scalable, and open, so you don’t have to choose between intelligence and interoperability.

From training to inference, the entire stack is being rebuilt to treat intelligence the same way we once treated code and capital. As a primitive. As infrastructure. As something you don’t just plug in when the pitch deck needs buzzwords, but something you build with from day one.

Intent isn’t a design philosophy. It’s the next operating layer. And the networks that figure that out first will not only win user trust, they’ll win time, attention, and allocation.

Memory Is the New Alpha

What do agents have that humans don’t? Besides 24/7 uptime, no burnout, and absolutely zero emotional baggage from that one time they bought the top on a meme coin? Memory. Lots of it.

But this isn’t some Hallmark-style memory lane. We’re talking about mission-aligned, protocol-specific, strategy-grade memory. The kind that knows how a protocol responded to liquidity crunches, how community governance evolved after each vote, how emissions schedules impacted price discovery, and how your DAO really behaves on Sundays before a major unlock.

Agents don’t just act. They anticipate. Trained on years of protocol data, token behavior, incentive loops, market structure, and even sentiment, they don’t wake up every quarter trying to relearn what they forgot. Unlike your average fund manager who claims to have “seen this before” but still panics every time the Fed tweets, agents remember everything. And they do it without arrogance, overconfidence, or recency bias.

This is where memory stops being storage and starts being strategy. An agent that understands your protocol’s actual operational rhythms can serve not just as a helper but as a co-governor. A rebalancer. A supply-side optimizer. It can monitor emissions, execute liquidity moves, adjust incentive curves, and flag governance proposals that feel off-pattern. All in real time.

You don’t need five dashboards and three analysts to make sense of the same signal. You need one agent who remembers what happened last time and knows how to respond. The value of that kind of memory isn’t just convenience. It’s alpha.

In a world where capital moves at the speed of code, memory is the difference between being reactive and being antifragile. When that memory is composable, protocol-native, and fine-tuned to mission, that is the new moat.

The hedge fund of the future isn’t a team of 80 analysts. It’s a small squad of agents with perfect recall, tuned incentives, and zero cognitive overhead. That’s not science fiction. That’s the direction we’re heading. And it’s already online.

The Agent-Economy Feedback Loop

Here’s where things get weird, and we mean that in the best possible way.

As AI agents take on infrastructure roles, they’re not just mindless executors of logic. They’re data factories. Every routing decision, every liquidity adjustment, every governance vote creates a trail of operational intelligence. And that intelligence doesn’t vanish into the void. It feeds right back into the models. The result is a system that doesn’t just run. It learns. It adapts. It compounds.

This isn’t your quarterly KPI review followed by an all-hands where everyone nods and forgets. It isn’t a Slack thread titled “Important” that nobody reads. This is real-time learning that maps behavior to outcomes and turns each action into fuel for smarter coordination.

In other words, we’ve crossed a threshold. AI isn’t a tool sitting outside the system. It is the system. It shapes the incentives. It optimizes throughput. It flags anomalies. And it does so with the memory, speed, and precision that makes most org charts feel like ancient scrolls.

This is the moment where AI becomes market structure. Not as a metaphor, but literally. The stronger your agent layer, the more fine-tuned your protocol becomes. This isn’t because you hired a genius with perfect market timing. It’s because you trained one. You embedded one. You deployed one with a mission and a memory.

This loop: action into data, data into model, model into smarter action, has become the new flywheel. If your protocol doesn’t have it, you’re not compounding. You’re just reacting. The edge belongs to those who build systems that think, not just systems that move.

The Venture Stack Gets Autonomous

Let’s talk about the part no one wants to admit yet. Venture capital itself is about to get agentified.

Every firm faces the same bottleneck. Too many decks, not enough context. Too many signals, not enough synthesis. Too much spreadsheet theater and not enough structured learning. But this is exactly where AI agents, properly trained and tightly aligned, step in. They can evaluate deals with real-time data. They can monitor portfolio health without waiting for your quarterly update call. They can model capital efficiency, flag risk scenarios, and benchmark founder performance in ways that no human analyst team can keep up with.

Picture a venture platform where your partners aren’t limited by caffeine and calendar invites. Instead, they continuously ingest telemetry across the portfolio. They process governance outcomes, track protocol activity, scan on-chain behavior, and triangulate all of it into actionable insight. It’s not just diligence. It’s mission-aligned inference running 24/7.

Now take that one step further. Imagine conviction not as a post-partner-meeting hunch, but as a signal. It’s weighted by probability. It’s trained on the full body of your firm’s historical decisions. It remembers every LP update, every exit, every red flag missed and every thesis confirmed. It doesn’t just echo the past. It evolves your strategy.

This isn’t just a more efficient fund. It’s a fundamentally new architecture. A venture platform that learns. One where every founder interaction, token vote, market shift, or smart contract deployment becomes part of the dataset. Where new funds aren’t just new capital, but fresh training cycles for smarter, faster allocation.

We’re not saying the human element disappears. But the center of gravity shifts. From gut checks to guided inference. From backroom intuition to transparent coordination. From institutional memory to computational memory that never forgets and never gets tired.

This is what autonomy looks like at the capital layer. And the firms that embrace it won’t just move faster. They’ll move smarter. They’ll stop making the same mistakes twice. And they’ll finally start playing the game at the speed of the system they’re investing in.

Where It’s All Headed: Capital as a Coordinating Species

We’ve followed the evolution from capital to code, and from code to cognition. So the question now is simple. What happens next?

The answer is coordination. Not the kind that happens in spreadsheets or Slack threads. Not the kind that gets scheduled, delegated, and slowly forgotten. We’re talking about something more primal. Coordination as an emergent property of capital. Capital that listens. Capital that adapts. Capital that knows when to act, with whom, and why.

In Part 4, we’ll explore what it looks like when the entire venture stack becomes multiplayer. When allocators, founders, and agents form a mesh network of incentives and execution. Where liquidity doesn’t just flow toward returns, but toward aligned behavior. Where governance isn’t just a checkbox, but a live coordination surface shared by humans and machines.

This isn’t science fiction. It’s what happens when you put autonomous infrastructure, intelligent agents, and programmable capital into the same system and let them run. What emerges is a new kind of organism. One made of code, coordination, and conviction. One that doesn’t just act, but evolves.

And yes, it might get weird. But if you’ve made it this far, weird is probably your comfort zone.

Stay tuned. The coordination layer is coming online.

Are you ready to browse the strategies that matter? Explore curated investment plays at Nautilus.Finance, and follow Tom Serres on X.com or LinkedIn for real-time guidance.

crypto[native]

Discussion about this post