I’ve been rethinking what actually survives in an agent product.
A lot of the very specific things will sooner or later become obsolete. Fixed workflows, specialized routines, little bridging features. Some can now be vibed out in hours. Some just stop making sense after a model upgrade.
The things that seem to survive are lower-level:
domain artifacts, domain tools, storage, execution, cron, runtime, workspace.
I used to think good product work meant understanding the user journey deeply and then building exactly the thing that solves it.
I still think the first part is right.
But for agent products, I’m starting to think the output of that understanding shouldn’t always be a feature or a workflow.
Maybe it should be the primitive.
What should be a primitive? Where should its boundary be? What should it expose? What should stay opinionated, and what should just be left to the model?
That feels increasingly like where product taste and engineering taste meet.
If you get those primitives right, the product starts growing with the models instead of getting invalidated by them, and more importantly, with the users.
Better models do more with the same primitives. Users compose them in ways you didn’t expect. New use cases appear without you explicitly building each one.
I think that’s the part I’m still trying to internalize:
understand the journey deeply, but don’t necessarily encode the journey.
Build the primitives underneath it.
I was watching an online course today and noticed I’m learning a bit differently now.
I used to focus mostly on what they were teaching.
Now I pay much more attention to why the lecturer prefers one practice over another, what actually works in practice, which conventions are shared across the industry, and which choices are just personal preference.
I can get most of the information from an LLM anyway.
Learning is shifting from learning information to learning taste.
an unexpected use case today:
a dev tagged it to deploy a specific revision of a single service to staging for compatibility testing.
we never built this as a feature. the agent already shares the same context + workflows as our devs, and has access to operate staging. the pieces just came together.
unexpected, but also kind of by design.
shipped 🫡
🏆 Win up to $40,000 trading on-chain equities.
To celebrate our launch with @OndoPerps , we’re running a 2-week trading competition.
1. Trade RWAs using TN's agents
2. Climb the leaderboard
3. Take home real rewards
Starts now. Ends in 14 days.
Join here → truenorth.xyz
It’s often tempting to say “we’ll fix it later.”
Especially in the AI era, because it feels like making it right later will also be cheap. I catch myself thinking this quite a lot. There’s an old engineering truth here: if you don’t write code, there are no bugs. AI writes code faster. It also writes bugs faster. So “we can fix it later” doesn’t necessarily get cheaper. You can accumulate code, bugs, and tech debt much faster now too. And the longer you build on top of a bad decision, the less local the eventual fix becomes. Turns out faster coding doesn’t really save you from bad engineering decisions.
It just lets you compound them faster.
putting just “Jeff Dean” on the slide should be more than enough
Replying to @JeffDean
We created a pitch deck to tell a handful of VC firms about us and what we were up to (a fun experience!). Here’s a few slides about our background and some of the things we’ve worked on from the pitch deck (it was fun putting together the list of people in our teams who have gone on to found a whole range of exciting companies). We are delighted to have selected @radicalvcfund
and @khoslaventures to lead our initial funding round, along with participation from @lightspeedvp, @kleinerperkins, Doerr Capital (@johndoerr), and Alphabet (@Google). We’ll be working with them to close our seed round over the next few weeks.
oh no, Mitchell is building the new tmux
oh no, the new tmux incorporated
xitter.cf/superlogical/status/20…
Hello, world. We've been building a terminal multiplexer and we think you're going to love it. Native apps (e.g., macOS/iOS), accessible from the web, multiplayer. From the creators of Ghostty and Echo.
superlogical.com/
Had a long call with an engineer today because a small service suddenly needed far more cluster permissions than expected.
It was originally just a dynamic scaler that reads pod status.
But somewhere in the planning loop between the engineer and AI, it grew into something that could also deploy and manage the Helm chart—a responsibility we had intentionally kept separate for safety.
80% of me thinks cutting that scope was the right call.
Smaller blast radius. Clearer ownership. Less chance of a tiny service quietly becoming a deployment platform.
The other 20% wonders whether I was just slowing things down.
I’ve become increasingly suspicious of my own engineering instincts in the AI era.
A lot of what we call “good judgment” was shaped when building software was expensive. But the cost is no longer static.
You have to think about the entropy you add, how much context the team can hold, how much faster people can move today, and whether better models will make today’s boundary look overly cautious later.
Still learning
hao retweeted
Headless Finance + The Intelligence Layer
The thesis for what onchain finance looks like on the other side of this cycle.
The shift.
For five years, liquidity was the game. Bootstrap TVL, bootstrap volume, subsidize LPs, farm the emissions. Every protocol that mattered was a liquidity magnet first and a product second. That game is largely over. Not because it stopped to matter, but because it stopped being scarce.
The numbers are obvious. Total onchain TVL sits above $150B. Stablecoin supply cleared $300B. Hyperliquid alone regularly clears $10B in daily perp volume. Onchain RWA is at $23B and compounding over 100% YoY. Cross-chain messaging moves billions weekly. The liquidity is here, deep enough, cheap enough, and increasingly composable across venues.
Liquidity became infrastructure. Infrastructure is not where the next set of returns lives.
What changed underneath.
Three things unlocked in parallel over the last 18 months, and the market hasn't fully priced what they mean together.
First, cross-chain rails matured. LayerZero, CCIP, intent-based bridging. Moving capital across chains stopped being a security nightmare and started being a routing decision.
Second, high-performance blockspace arrived. Eth, Sol, Base, Robinhood, Arbitrum. Sub-second finality, cents-per-transaction cost, throughput that supports real trading frequency. Agent-driven execution was economically impossible on 2021 Ethereum. On today's chains it's routine. That's the physical layer that makes 24/7 agent operation viable.
Third, vertical AI got good enough for high stakes execution. Not general chatbots. Domain-specific agents with memory, tool use, and deterministic guardrails. Harvey for legal. Cursor for engineering. This class of agent can now hold context, reason about tradeoffs, and act within bounded authority.
Three unlocks. One conclusion. The pieces exist to abstract finance away from the protocol UI entirely.
The new bottleneck.
If liquidity isn't the constraint, what is then? Cognitive load and execution complexity.
Blockchains are still hostile to non experts. Wallets, gas, approvals, chain selection, bridge routing, slippage tolerances, MEV protection, position management across 6 venues. Finance itself, before any of the crypto complexity, is hostile to most people. Reading a chart, sizing a position, understanding funding rates, timing rebalances, tax lot selection. The gap between "capital exists" and "capital deployed intelligently" is where the value now sits.
You cannot solve this with a better wallet UI or a nicer dashboard. Every attempt has failed. The interface itself is the problem.
The pattern others already lived through.
This shape is not new. Every prior technology wave went through the same transition once its underlying resource became abundant.
Retail: Shopify and Stripe became headless commerce. Amazon's recommendation engine became the intelligence layer. Storefronts stopped being the point.
Cloud: AWS and GCP became headless compute. Vercel and Netlify became the intelligence layer on top. Server management stopped being the point.
Search: Google's index became the headless layer. Ranking, personalization, and now generative answers became the intelligence layer. The ten blue links stopped being the point.
Every one of these transitions followed the same pattern. The primitive commoditized. The interface that abstracted the primitive captured the value.
Finance is next. Liquidity is the primitive. The intelligence layer is where the abstraction happens.
What this means for protocols.
Protocol UIs will stop to matter. Not immediately and not uniformly, but directionally. Users will not touch Uniswap the interface. They will consume Uniswap the AMM through an agent that routed to it because it had the best fill for the intent. Same for Aave, Hyperliquid, Morpho, Pendle, Ondo, and everything downstream of them.
When the interface layer disappears, brand loyalty disappears with it. Today, a lot of protocol volume runs on habit. Users open Uniswap because it's Uniswap. Borrow on Aave because it's Aave. Trade perps on Hyperliquid because that's where they've always traded perps. The interface is where brand equity converts into flow.
Once agents sit between the user and the protocol, that conversion breaks. The agent doesn't have brand loyalty. It has a routing table. If Fluid quotes a tighter spread than Uniswap on that specific swap, the agent routes to Fluid. If Morpho gives a better borrow rate than Aave for that duration and collateral, the agent routes to Morpho. The user never sees the choice, never argues with it, never notices which protocol they used. Execution quality wins the trade every time.
The competition for protocols becomes what it should have always been: order matching quality, settlement finality, capital efficiency, and verifiability. That's a cleaner game. It rewards the teams whose engineering is genuinely best-in-class. It stops rewarding the teams whose main asset was user recognition and distribution habit.
Some protocols will love this transition. Their spec is already superior and their revenue was capped by lack of front-end reach. Agents give them distribution they could never have earned on brand. Others will lose share fast. Their volume was inherited, and the moment the routing layer stops asking users where they want to go, the volume stops flowing.
Protocols become pipes. Pipes get paid on volume and reliability.
What this means for interfaces.
The interface layer stops being a place where you click buttons. It becomes an agent, or a set of agents, that takes intent and produces execution.
The competition for interfaces becomes: reasoning quality, personalization depth, execution routing, security discipline, and trust. Reasoning quality means the agent formulates thesis, weighs positioning, and builds conviction better than the user could alone. Personalization means the agent knows how the user thinks about risk, sizing, and holding periods, and adapts every recommendation to that. Execution routing means the agent knows which venue to hit, when, how to break up size, and how to filter for security. Contract age, audit status, honeypot detection, approval hygiene. A well-designed agent doesn't just find the best price. It filters out the fills that would cost you the position entirely. Trust means the user delegates with confidence because the guardrails are verifiable.
Interfaces become desks. Desks get paid on outcomes and retention. Two different games and moats. Different winners.
What's still missing.
The thesis is not fully deliverable today. Being honest about what's missing is what separates a real vision from a pitch. Four things need to happen in the next 24 months.
Guardrails. Agents acting on capital need bounded authority, permissioned actions, and human-in-loop for size. Non-custodial is table stakes. Beyond that, we need shared standards for what agents are allowed to do without asking.
Interoperability. Agents from different providers need to talk to each other and to protocols in a standardized way. MCP is a start. It's not the finish.
Verifiability. Agent decisions need to be inspectable and replayable. Users, auditors, and regulators need to see why an agent did what it did. This is the compliance layer that unlocks institutional flow.
A world model for finance. General purpose models will not price risk correctly at the margin. The next moat in this space is a model that understands markets, positioning, funding, correlation, and regime shifts natively, not as a translation from general reasoning. Whoever builds this owns the reasoning ceiling.
The counter-argument.
The obvious pushback: users want direct control, and an agent layer introduces trust risk. Fair, and it’s answered by architecture.
Non-custodial by design. User keeps the keys. Agents propose, users approve, or agents execute within pre-approved bounds that the user set.
Every action logged, every decision inspectable. Human-in-loop for anything above the delegation threshold. This is not a hypothetical. This is what a well-designed agent brokerage looks like today.
The alternative, users manually managing 12 positions across 6 venues on 3 chains, is not control. It is exhaustion. Real control is setting policy and letting execution follow.
Where TrueNorth sits.
TrueNorth is not building a chain. Not building a DEX. Not building custody. Not building an alpha generating quant strategy that we then sell you access to.
We are building the intelligence layer for finance. We aggregate liquidity across venues, formulate thesis across data sources, and execute across protocols. Let protocols be protocols. Let agents be the desk you need.
The user sets intent and risk. The agent handles thesis, aggregation, routing, and execution. The human stays at the trigger for delegation and oversight. Every session labels behavior, preferences, and outcomes, and the desk learns the user faster than any competitor because we own the reasoning layer end to end.
Agent mediated execution is also structurally more secure than self-directed trading for anyone who isn't already a sophisticated onchain user. Every transaction the agent proposes runs through a security baseline that only power users know to apply manually. Contract verification.
Approval scope minimization. Honeypot and rug filters. Wallet exposure caps. Signature review. The opsec discipline that keeps veteran traders from getting drained becomes the default posture for every user, not a skill they have to acquire. Retail loses more money to bad opsec than to bad trades. The agent closes that gap by making good opsec the floor, not the ceiling.
The picture at full realization.
A world where any user, anywhere, expresses financial intent in natural language and has that intent routed across the full onchain liquidity surface, priced against every venue, executed with institutional discipline, and monitored 24/7 by agents that know how they think.
Wealth advisors become commodity. Retail brokerages get disintermediated. Capital flows across asset classes and chains without friction. The protocol layer runs quietly underneath, doing what it does best. The intelligence layer sits on top, doing what humans and interfaces alike were never able to do at scale.
That is what headless finance plus an intelligence layer means.
That is the game of the future.
hao retweeted
Everyone on X feed is still posting "look what the model can do." That conversation is over...
This week's summary at @aiDotEngineer World's Fair with @alanwuuuuuu.
1. Evals Have "Eaten the Conference" — AI Engineering Has Grown Up
-The conversation has shifted from "Look what the model can do" to "Prove it doesn't regress in production."
-Evals, observability, gates, controls, and trust are now core engineering disciplines.
-Production teams obsess over reliability more than raw capability.
-"Trust has officially become an engineering discipline." The "back office of AI" (observability, authority layers, governance) has arrived.
2. Agentic Systems & "Software Factories" Are the New Frontier
-Heavy focus on real agentic workflows, multi-agent orchestration, debugging agents, and memory systems.
-Software Factories emerged as a hot new concept: self-improving codebases and systems that get better over time (recursive self-improvement loops are apparently already running in early form at frontier labs).
-Context engineering has evolved well beyond basic RAG → graphs, advanced memory systems, compaction, and business knowledge integration.
3. Long Context Is "Solved" (Sort Of)
-The quadratic cost of attention is no longer a fundamental blocker.
-The approach: intelligently select relevant subsets from huge contexts rather than naively stuffing everything in.
-Expect billion-token context windows to become practical soon.
4. Open-Source Momentum (Especially Chinese Labs)
-Strong buzz around GLM models (Zhipu AI / chat.z.ai) and Minimax.
-They’re seen as impressive and important for releasing strong open weights.
-Local AI and inference tracks were very popular.
-Hugging Face had fireside chats highlighting this.
5. Voice & Multimodal Is Ready (and Underused)
-Realtime voice-to-voice is now genuinely good.
-Many believe AGI interfaces will be mostly spoken, not typed.
6. Other Insights
-Benchmarks are broken — none are fully trustworthy right now. Cheap/fast inference providers sometimes quietly reduce accuracy.
-Debate on AI-generated code: Some say review everything, others say you still need deep problem understanding either way.
-Alignment is considered "solved" if done properly (Erik Meijer got a lot of praise here).
I think it’s this kind of small thing that slowly made me lose trust in Claude Code.
I only started using Codex as a backup when I hit Claude Code limits, which happened a lot. But at some point I just found myself fully moving into Codex GUI.
SSH, remote control, and mobile UX are probably the main reasons. More than that, it feels like a product made by people who are close to the workflow. The product feels lived-in: the defaults, the recovery paths, the UX choices, and the sense that someone is noticing the annoying parts and fixing them.
At the same time, what I kept getting from Claude Code was more mixed: clunky remote control features, token usage I didn’t really trust, and confusing decisions like removing claude -p and then bringing it back.
Eventually the backup became the thing I open every day.
sneaky, but also clever. thereallo.dev/blog/claude-co…




















