AI on Arem

Coherence is the scarce good

Sat, 02 May 2026 00:00:00 +0000

On April 18, 2026, an attacker drained 116,500 rsETH from the cross-chain bridge of Kelp DAO. Roughly $292 million.

Not because of a bug. Because of a decision that stayed invisible.

Kelp had chosen a 1-of-1 DVN configuration, a single verifier, against the explicit recommendations of its own infrastructure provider. That choice never made it into a proposal, a public debate, or any record before the incident happened.

Two days later, Arbitrum’s Security Council froze $71 million.

The debate started immediately. On one side, those who saw this as proof that nothing in crypto is truly decentralized. On the other, those who saw an emergency intervention against a state-level actor as not just legitimate but necessary.

Both positions are coherent. Both miss the point.

Because what happened here doesn’t begin with the hack. It doesn’t begin with the freeze either.

It begins at the moment a structuring decision can be made without ever being seen.

DeFi doesn’t break because of bad code.

It breaks because some decisions stay invisible until it’s too late.

And as long as those decisions stay invisible, every crisis will keep pushing the ecosystem toward an impossible choice between emergency centralization and principled inaction.

What becomes scarce

Decentralized organizations have solved two major problems. They aggregate capital with unprecedented efficiency. They aggregate preferences through sophisticated voting mechanisms.

But they have built almost nothing for a third aggregation, even though it may be the most decisive: the aggregation of intelligent work over time.

That work exists everywhere. It takes the form of research, discussions, technical trade-offs, disagreements, intuitions. It flows through multiple channels and then disappears. Each new session starts where the previous one left off, with no usable trace in between.

Intelligence gets produced. It doesn’t accumulate.

This flaw stayed invisible for a long time, for a simple reason: intelligence used to be scarce.

It isn’t anymore.

AI has tipped intelligence into abundance. What’s now in short supply isn’t analysis or code. It’s the capacity to hold together what’s already been produced.

Intelligence is becoming abundant. Coherence is the bottleneck.

This shows up in different but converging diagnoses. Aragon observes that the volume of decisions grows faster than available attention. Twyne points at the absence of cumulative memory and continuity in the work of agents.

Three observations. One shared limit.

Coordination distributes tasks. It doesn’t produce continuity.

And in that gap, something deeper is shifting. If a structuring decision can be made without being visible, without being documented, without being challengeable, then the system that contains it is not decentralized in any strong sense.

We didn’t decentralize power. We decentralized its interface.

This shift produces very concrete effects. It favors those who control the context, those who hold informal memory, those who can act without making their decisions legible.

Kelp is not an anomaly.

It’s a system revealing how it actually worked, at the moment it failed.

Aragon, the art of not governing

In this landscape, Aragon offers one of the most advanced architectures.

Their starting point is clear: onchain governance frameworks, in their current form, have not given organizations a reliable way to act with precision. Their answer is to shift the central primitive. The proposal is no longer what structures the system. The permission is.

With OSx, governance becomes an architecture of rights. Capabilities are defined explicitly, then distributed and recombined through modules.

The decisive step comes with the notion of policy. Proposals are reserved for genuinely new decisions. Everything else, recurring payments, predictable allocations, repeatable configurations, is codified as executable rules.

Evan Aronson’s formula puts it precisely: “Policy design is an art of not governing.”

This isn’t about reducing governance. It’s about relocating it. A decision is no longer a one-off event. It becomes a rule that’s both binding and executable, with no need for ongoing intervention. I’ve worked through this intuition philosophically in an earlier piece on gentle power; Aronson gives it its technical form.

With Linked Accounts, Aragon pushes the logic further by making the purpose of fund flows explicit. Organizational structure stops being implicit. It becomes legible inside the system itself.

This work is substantial. It introduces a kind of legibility that was missing.

But that legibility operates in a deterministic frame. It assumes the relevant actions can be anticipated, that rules can be defined in advance, that behaviors can be bounded.

Anything that escapes that frame stays out of view. Upstream technical trade-offs, informal decisions, the ongoing production of meaning, anything that doesn’t stabilize into a rule remains invisible.

Aragon makes decisions executable. It does not make their formation visible.

Twyne root-archetype, the grammar of agents

This is where root-archetype steps in, the agent governance layer Twyne uses internally and has released under an open license.

With root-archetype, the move is to introduce, on top of application code, a layer that produces nothing directly but defines the conditions of production themselves. Roles, memory, handoff protocols, shared constraints. Everything that gives shape to continuity in collaborative work.

The gesture is simple. Its effects run deep.

A session no longer starts from scratch. Context carries over. Knowledge stops evaporating between contributions.

Intelligence starts to compose itself.

Released under an open license, this model is meant to become a primitive. It offers a minimal grammar from which an ecosystem can structure itself.

The symmetry with Aragon is clear. Aragon codifies decision on the capital side. Twyne root-archetype codifies the grammar of work on the agent side. One structures what gets decided, the other structures what makes decision possible.

But neither of them makes visible how those two dimensions interact.

Twyne itself, the credit-delegation primitive the team is building, illustrates precisely why this layer is missing. The safety of a credit primitive depends on upstream decisions: parameter choices, oracle picks, verifier setups. Exactly the kind of decisions that, when they stay invisible, become tomorrow’s exit conditions. What happened at Kelp is of that exact nature, which is what makes the legibility question anything but theoretical.

The missing layer

This is where the problem becomes legible.

Neither Aragon nor Twyne root-archetype makes visible how decision, capital, and production hold together over time.

That invisibility is exactly what made Kelp possible.

What’s missing isn’t another tool. It’s a layer.

A system that makes structuring decisions visible before they produce irreversible effects.

We can name it plainly: an Organizational Observability Layer.

A layer of this kind doesn’t just trace outputs. It represents how an organization actually functions. It connects actors, human and agent, with their tasks, their dependencies, their decision points. It holds the memory of choices, alternatives, disagreements. It formalizes handoffs. It exposes constraints. It sustains a transversal watchfulness.

Making the actual functioning of a system visible is becoming a strategic capability.

Today, contributing too often means just adding work. In an organization with such a layer, contributing means modifying a shared state.

It’s what turns a succession of initiatives into a cumulative process.

It also clarifies a distinction that often gets blurred. Coordination answers who does what. Coherence answers a more demanding question: does the system, as a whole, still make sense?

Current tools improve the first. The second still has to be built.

The false alternative

The debate that opened after the Arbitrum freeze reveals exactly where we are.

Should we intervene or not? Should we accept emergency centralization, or hold strict fidelity to principle?

The questions are legitimate. They just arrive too late.

They assume the incident has happened and that we now have to pick between two flawed options. They never ask what made the incident possible in the first place.

Had Kelp’s DVN configuration been visible, documented, challengeable before it shipped, the choice could have been different. Or owned. Or constrained.

In any of those cases, it would have lived in a shared space.

Every incident of this kind is a failure of visibility before it is a failure of security.

Recognizing this doesn’t remove the risk. It moves the ground on which the risk has to be addressed.

Decentralization no longer plays out solely in the ability to react. It plays out in the ability to make decisions visible before they become irreversible.

That’s a third path. Not a compromise. A reframing.

The natural slope

Building such a layer comes with real tensions.

Over-formalization can rigidify the system. A too-clean representation can hide misalignment, unless it makes explicit room for dissent.

But the deeper risk lies elsewhere.

Any layer of legibility creates an asymmetry. Whoever sees more than others has an advantage. Without an explicit mechanism, that asymmetry drifts toward capture: by a central team, by a vendor, by an external actor.

What isn’t held as a commons becomes a point of control.

Holding a coherence layer as shared infrastructure is the only regime that doesn’t take care of itself. Every other regime emerges without effort.

A political stake

Coherence is not a technical problem. It is a political choice.

It determines who can see, who can understand, who can challenge. Today, those dimensions stay largely implicit, and therefore default-controlled by whoever already occupies a central position.

This is a call on our vigilance, in the same direction I proposed in a public grammar of risk.

Engaging with a protocol shouldn’t be limited to assessing its code, its tokenomics, or its formal governance. It should include a simpler, more demanding question: how are structuring decisions made visible?

That is the dimension Kelp lacked. And it is the dimension that will determine how robust the systems to come actually turn out to be.

To close

Aragon and Twyne root-archetype have laid down essential bricks.

One on decision and capital.

The other on production and memory.

But the layer that would let those two articulate is still to be built.

Without it, every crisis will keep forcing a choice between centralization and powerlessness.

With it, structuring decisions become visible before they become irreversible.

We haven’t failed to build decentralized systems.

We have failed to make them legible.

That legibility, that coherence, is what is now genuinely at stake. And what remains to be invented.

3. DeFi as a Laboratory of Delegation

Mon, 13 Apr 2026 13:00:00 +0000

Series opening: Self-Custody, But How Far?

In DeFi, an idea quickly turns into a permission, a risk rule, or a signature.

That is what gives DeFi its head start.

In many digital environments, ambiguity can last a long time. Actions remain diffuse, consequences are spread out, mistakes can be patched over. In DeFi, much less so. The distance between a market read, a recommendation, a click, an approval, and an execution is short.

A dashboard is not just an interface. It can shape how risk is seen. A wrapper is not just a service. It can reframe what counts as safe. An agent is not just an assistant. It can monitor, propose, prepare, trigger, or — within certain bounds — act.

That is why DeFi sees earlier than most sectors what delegation becomes once it stops being an abstract convenience and takes the form of real permissions.

The protocol no longer sums up the system

We still talk too easily about “protocol risk,” as if the protocol alone were enough to describe the object.

It no longer is.

Between the user and the protocol there now sits an entire software environment: specialized interfaces, dashboards, wrappers, copilots, treasury tools, research layers, monitoring tools, coordination services, and in some cases already execution agents.

The point is not to cast suspicion over every one of these objects. The point is to see that they redraw the map of trust. Even when the base protocol is solid, the surrounding environment can become the main place where the problem reappears: what we see, what we understand, what we think we understand, and what we are being nudged to do.

What AI changes materially

This is not just a conceptual shift. It is a material one.

AI dramatically lowers the cost of producing software layers around protocols: dashboards, assistants, wrappers, analysis tools, micro-services, orchestration layers. Builders ship faster, test faster, iterate faster. In many cases, that is genuinely good news.

But the cost of verification, qualification, and prudent integration does not fall at the same pace.

So the issue is not that tools are being built with the help of AI. The issue begins when the cost of producing a service falls much faster than the cost of understanding it, reviewing it, and integrating it well.

At that point we do not just have more software. We have more surfaces of trust to evaluate.

Vibe coding: not a scandal, a reveal

The term is often used too loosely. It is better handled with care.

Not every AI-assisted build is vibe coding in the strong sense. Not every tool built quickly is unserious. And it would be absurd to accuse any specific dashboard, service, or project without evidence.

What the phenomenon does reveal is more structural: an environment in which access layers, analysis layers, orientation layers, and sometimes already execution layers can be produced very quickly — an environment in which apparent fluidity can improve faster than the community’s capacity to judge what has actually been reviewed, understood, bounded, and owned.

The issue is not the builder’s moral failure. The issue is the acceleration of the context in which the user has to exercise judgment.

Two protocols that make the problem legible

Money League and Polaris are not used here as two more protocols to “watch,” nor as stabilized objects.

In both cases, these are still developing systems whose public shape can evolve. They are therefore being treated with caution, on the basis of their current presentation, as provisional figures rather than fixed models. Polaris in particular may well end up confronting the question of an agentic layer more explicitly than it does today.

These two cases matter because they make the same problem legible in sharply different ways.

Money League presents itself as a permissionless infrastructure for launching and coordinating decentralized stablecoins, with a modular architecture, shared incentives, and above all an explicit thesis about agentic money: prediction markets inside the monetary loop, proof of agent competence, agents as stabilizers, and the horizon of an inter-agent economy settled in fully onchain assets.

Polaris, by contrast, presents itself as an onchain, immutable, trustless stablecoin operating system centered on a tightly bounded monetary core, internal yield mechanisms, and a modular extension logic.

The value of the comparison lies in that gap. Money League helps us think about how far agentivity can climb into monetary infrastructure. Polaris reminds us that before any system becomes more powerful, someone still has to decide what must remain bounded, legible, and politically bearable.

Money League: pushing the agentic horizon further

Money League matters because it pushes a hypothesis many still prefer to keep at the edge: the agentic layer can rise all the way into money itself.

In its public imaginary, agents do not stay at the margins. They enter the loops of stabilization, forecasting, coordination, and management. Its strength is that it makes this horizon visible without hesitation. Its limit, for our purposes, is that it says more about the sovereignty of the system than about the practical sovereignty of the person doing the delegating.

Polaris: returning to the question of constitution

Polaris is, in that sense, a useful counterpoint.

Its public interest does not begin with spectacular agentivity, but with a more constitutional architecture: an immutable core, limited stewardship, and a small number of adjustable parameters constrained inside coded bounds.

Its strength is to remind us that a system does not become more legitimate simply because it automates more. It becomes more intelligible when it knows how to distinguish what must be delegated, what can be adjusted, and what has to be withdrawn from ordinary variation.

What they show together

Taken together, these two cases make a tension visible that DeFi will meet more and more often: how far should agentivity be allowed to rise, and at what point should the constitution of the system be reinforced instead?

This is no longer just a UX question. It is monetary, institutional, and operational.

Morin: no local limit abolishes the systemic problem

This is where Morin helps us avoid two symmetrical naïvetés.

The first would be to believe that more design, more limitations, and more explicit permissions are enough to solve the issue.

The second would be to conclude, conversely, that the mere presence of another layer makes everything suspect.

Morin forces us to hold two truths together.

Yes, we need limits. Yes, we need bounded permissions. Yes, we need legible architectures.

But no local bound, no elegant module, no isolated proof of integrity abolishes the ecology of action. A system can be well designed at the local level and still produce unexpected systemic effects: mimetic behavior, routines of overconfidence, new dependencies, procyclical coordination, misread incentives, collective blind spots.

So the question is not only: was the action authorized? It is also: what does the multiplication of these actions produce inside an environment populated by tools, dashboards, agents, and users who are not all seeing the same world?

Verifiability: a valuable aid, not a substitute for judgment

It is perfectly natural that calls for sovereign AI and verifiable AI resonate in web3. They speak a familiar language: control, integrity, proofs, the reduction of blind trust.

That direction matters. It can make certain delegations more legible, more attestable, more contained.

But the hierarchy of problems has to remain intact.

Verifiability does not replace common sense. It does not decide for us what should have been delegated in the first place. It does not guarantee that systemic effects will be desirable.

Proofs, logs, limits, action policies, and cryptographic primitives can improve the integrity of certain operations. They do not relieve us of defining the mandate, accepting the limits, or answering for the uses.

Control, integrity, measure

What is rising in web3 is not illegitimate. The point is to keep the order of problems clear.

Sovereign AI

Addresses the question of control: where the system runs, who depends on whom, what data leaves the perimeter, and which permissions are actually in play.

Verifiable AI

Addresses the question of integrity: what can be attested, reviewed, proved, or reconstructed.

But measure remains decisive

Neither of these directions removes the need to answer the harder question: what should be delegated, within which limits, and with what possibility of taking back control? Mathematics and cryptography can make certain operations more attestable; they cannot replace judgment, responsibility, or the ecology of action.

A minimal grid for evaluating an assisted or agentic DeFi tool

Before using a dashboard, wrapper, copilot, agent, or third-party service, it is worth running it through a simple filter.

1. What kind of thing is it?

A protocol, an interface, a third-party tool, an agent, or simply a visualization layer?

2. How far does it intervene?

Does it inform, recommend, prepare an action, or actually act?

3. What permissions does it require?

Does it touch a wallet, messages, private data, automations, onchain execution, or external calls?

4. What bounds are explicit?

Amounts, action types, confirmations, delays, allowlists, sandboxing, functional scope?

5. What is actually verifiable?

What can be reviewed, understood, audited, or reconstructed?

6. Is it reversible?

Can you cut the tool off without losing access to the protocol, to the underlying risk, or to your essential capacity to act?

7. Who is responsible for what?

The protocol, the builder, the operator, the user? If the answer is blurry, so is the trust model.

What this series was trying to show

The argument can be stated simply.

Crypto learned how to defend assets against capture. It is now discovering that it must learn to defend, with the same rigor, attention, judgment, organization, and the capacity to act.

The problem will be solved neither by nostalgia nor by acceleration for its own sake.

It calls for more legible protocols, better-bounded tools, less magical architectures, more responsible builders, and users less inclined to confuse new power with quiet abdication.

It also asks for something harder: the willingness to accept that no local proof, no elegant automation, no isolated instance of cryptographic integrity can ever fully replace wisdom about systemic effects.

That is where the most serious continuation of crypto’s promise may now lie.

Not only in protecting what we own. But in learning not to surrender too quickly what still allows us to act.

2. Delegate Without Handing Yourself Over

Mon, 13 Apr 2026 12:00:00 +0000

Series opening: Self-Custody, But How Far?

The problem is no longer whether to use AI. The problem is how far to let it in.

Too much of the AI debate hardens into a lazy binary. On one side: acceleration without brakes — wire everything up, automate everything, move faster. On the other: principled distance — keep away, distrust everything, and congratulate yourself for your supposedly clearer austerity.

Neither posture survives ordinary life for very long.

The serious question is harder: what kinds of delegation can we accept without losing command of our own practice?

Web3 readers already have one useful instinct. They learned in other domains that performance alone does not make a system legitimate. You still have to ask who controls what, within which limits, and under what conditions of reversibility.

Applied to AI, that instinct now has to become a discipline.

Assistance, delegation, abandonment

The first task is to separate what the moment keeps trying to blur.

Assistance is the simplest case. The tool helps, suggests, reformulates, accelerates. It expands our capacity to act without displacing the center of decision.

Delegation begins when the tool no longer just helps. It preserves context, reorders, filters, prepares, monitors, preselects, or triggers certain operations within a defined perimeter.

Abandonment begins when delegation becomes too broad, too opaque, or too comfortable to remain genuinely governed. The system still appears to serve us, but it becomes increasingly hard to explain what exactly it is doing, why we trust it, and what it would take to take back control.

These are not the same thing. And yet many current uses slide from the first into the second, and sometimes into the third, without ever naming the shift.

The real test is ease

The problem of delegation does not show up first in extreme cases. It shows up in easy ones.

The decisive moment is not usually when a system suggests some absurd transaction. It is when, day after day, it becomes normal for it to read for us, sort for us, reconnect for us, monitor for us, and prepare work before we even arrive.

Here again Morin helps. The danger is not only spectacular error; it is dependence quietly formed in the continuity of service. We then begin to mistake an increase in power for a thinning of presence.

What threatens autonomy is not always hostility. Often it is softness.

Where individual responsibility begins

This needs to be said plainly.

Protocols, builders, and tool providers have duties of clarity, boundary-setting, and prudent design. But they cannot carry the whole burden of educating users or operators determined to delegate everything without discernment.

There is, therefore, an irreducible form of individual responsibility that has to be recovered.

Vitalik Buterin offers one of the clearest practical expressions of this concern when he argues for a local-first, compartmentalized, tightly bounded LLM setup. The value of that setup is not that it provides a universal template. Its value is that it makes one thing unmistakable: as AI becomes an ordinary environment for action, the decisive question is no longer just model capability, but the limits we are willing — or unwilling — to place around delegation.

That does not mean becoming paranoid. It does not mean retreating into some heroic austerity. It means asking, with a little firmness: what am I actually trying to gain, and what am I unwilling to lose in the process?

The question is harder than it sounds. Most of us want the same things: more speed, more clarity, less friction, less fatigue, more continuity. The trouble is that these gains have a cost — and the cost is not always paid in data. Sometimes it is paid in habits of dependence.

A minimal discipline of delegation

There is no perfect stack. There is, however, a minimal discipline simple enough to use without turning into a purity program.

1. Keep the core of judgment in your own hands

Exploration, mapping, summarizing, and comparison can all be assisted. But the moment a reading turns into an actual judgment should remain visible. If you no longer know where help ends and pre-decision begins, you have already delegated too much.

2. Bound action before you expand assistance

The danger is not that a system is intelligent. It is that it is intelligent and deeply connected. A text assistant does not carry the same risk profile as a tool wired into messaging, sensitive documents, automation, a wallet, or execution rights. The wider the access, the sharper the boundaries need to be.

3. Prefer legible layers to magical ones

A good tool is not just one that works. It is one whose role can be described simply. If it takes five explanations to understand what it sees, what it keeps, what it prepares, what it can trigger, and what stops it, the delegation is already too opaque.

4. Treat comfort as a warning sign

Comfort is a real benefit. It is also often the moment when vigilance starts to drop. A mature AI practice does not reject ease; it refuses to become hypnotized by it.

5. Build the way back before you need it

Healthy delegation has to remain reversible. If you cannot unplug a tool without losing the intelligibility of your practice, access to essential information, or the ability to act without it, then the tool is already taking up too much ground.

A workflow more useful than an ideal stack

For many everyday uses, a clean discipline of delegation already changes a great deal.

Keep in your own hands

Decisive interpretation, capital allocation, reputationally sensitive choices, and any access involving keys, secrets, or wide permission scopes.

Safe to assist

Exploratory research, topic mapping, summarization, reformulation, comparison, and note structuring.

Delegate only inside a bounded perimeter

Monitoring, draft preparation, classification, low-consequence automations, and narrow coordination tasks.

Never delegate without explicit friction

Signatures, fund movements, external messages, irreversible actions, and any modification of critical permissions or system parameters.

What this second piece was trying to make practical

We are not going to get through this moment by pure refusal. Nor will we get through it by delighted surrender.

What we need is something else: a way of living with AI without handing over, in a single motion, the very faculties it makes harder to notice.

That calls for less purity than poise. Less grand moralizing than an art of limits.

The third piece moves the question onto its sharpest testing ground: DeFi, where every delegation eventually takes the form of a permission, a bound, a risk, or an architecture.

1. The Next Frontier of Self-Custody

Mon, 13 Apr 2026 11:00:00 +0000

Series opening: Self-Custody, But How Far?

We learned not to leave our assets with custodians. We have not yet learned not to hand our judgment too quickly to new intermediaries.

Crypto began with an intuition that looked technical at first and turned out to be much larger: wherever an intermediary can be removed from the equation, it is usually better to learn how to live without it.

From that intuition came wallets, habits, slogans, and forms of caution. Not your keys, not your coins did more than teach a generation of users to distinguish convenience from control. It changed the way they moved through the digital world.

What has not happened yet is the extension of that discipline to our own faculty for judgment.

We know how to ask where the funds are, who controls permissions, where the points of capture lie. We are far less used to asking where the model runs, what data it sees, how much of our work it absorbs, what it prepares on our behalf, what it saves us from doing, and what kind of dependence takes shape as it becomes hard to do without.

The center of gravity has moved. For years we talked about empires of data. We now have to talk about empires of delegation.

What has actually changed

Web2 mostly captured traces: our clicks, our preferences, our social graphs, our attention.

This moment adds a more intimate layer. AI enters our notes, archives, queries, reading habits, summaries, work routines, information triage, draft formulations, preparatory judgments, and in some cases already parts of action itself.

It is no longer just a tool. It becomes an environment — sometimes a work environment, sometimes a mental one.

And once a tool becomes an environment, the question changes. The point is no longer just whether it is useful. The point is what it reorganizes in us: how we read, rank, remember, anticipate, and decide.

For a web3 reader, that shift is decisive. Trust minimization no longer concerns only assets, contracts, or execution rails. It reaches something harder to preserve: discernment.

A deeply crypto contradiction

This is not really about hypocrisy. The problem is more uncomfortable than that — and more revealing.

Crypto has always been drawn to tools that produce an edge: more speed, more clarity, more informational asymmetry, more capacity to explore, compare, and execute. It makes perfect sense that the space would be among the first to embrace persistent copilots, augmented workflows, agentic layers, and systems that preserve context while compressing time.

So the contradiction is not moral. It is structural.

Two legitimate demands are colliding. On the one hand: do not depend on a trusted intermediary. On the other: gain speed, clarity, and processing power through systems that keep getting stronger.

The first built a culture. The second is beginning to rearrange its habits.

No slogan will resolve that tension for us.

The age of setups

That is why the current fascination with AI setups deserves to be taken seriously.

One builder runs Claude through Telegram. Another has agents pass task state through .md files. A third organizes memory in Obsidian, plugs in search tools, ties the whole thing into coding or research workflows, and starts the day with the sense that the machine has already been working through the night.

None of this is scandalous in itself. But all of it says something precise about the present.

We are no longer looking only for answers. We are looking for continuity.

We want systems that preserve context, reconnect scattered fragments, surface what must not be forgotten, reorder notes, watch what needs watching, prepare the ground, and make us feel that part of the work has already been done before we even sit down.

That promise is powerful. It is also exactly where sovereignty has to be rethought.

The question is no longer only whether a tool is spying on us. We also have to ask what it is taking over inside our relation to the world: memory, monitoring, pre-sorting, classification, recombination, the first movement of discernment. These operations look secondary — until we realize they already shaped a decisive part of the way we act.

Morin, or the useful bad news

This is where Edgar Morin becomes newly useful.

Morin forces us to think together what we would rather keep apart: autonomy and dependence, local power and systemic effects, service rendered and gradual dispossession. Applied to AI, the lesson is severe but clarifying: a tool of augmentation can become an infrastructure of relinquishment without ever ceasing, locally, to be useful.

The danger does not necessarily arrive as a visible catastrophe. More often it settles in under the appearance of comfort.

You notice quickly when you left your funds with a dubious custodian. You notice later when you have outsourced too much of your reading, your memory, your sense-making, or the preparation of your decisions.

Cognitive dependence rarely looks like coercion. More often it looks like help that has become second nature.

The issue is not only the models. It is also the surrounding software.

The problem cannot be reduced to frontier models, major labs, or the opposition between local and cloud.

It also concerns the environment AI is helping to proliferate around protocols: dashboards, wrappers, research tools, specialized assistants, monitoring layers, coordination services, micro-products built quickly — sometimes carefully reviewed and robust, sometimes not.

We need to be precise here. Using AI to build software is not, in itself, a problem. Not every AI-assisted build is vibe coding in the strong sense.

The issue begins elsewhere: when the cost of producing a service falls much faster than the cost of reviewing it, understanding it, and qualifying it.

At that point we do not just have more tools. We have more surfaces of trust to evaluate.

And in web3, where a dashboard, an interface, or a copilot can shape a risk reading, an allocation, a signature, or an execution path, that shift matters a great deal.

What this first piece wanted to make visible

The question, then, is not whether AI is compatible with web3 culture. It already is — almost too well.

The real question is more awkward: can crypto extend to cognition, organization, and action the same demands for sovereignty it learned to formulate for assets?

We now know where the fault line runs. A culture of self-custody that never asks what it is handing over to cognitive intermediaries may end up missing the most important stage of its own development.

The next piece starts from there: how to recover a discipline of delegation firm enough to matter and simple enough to use.

Intro: Self-Custody, But How Far?

Mon, 13 Apr 2026 10:00:00 +0000

Crypto taught itself not to leave assets in someone else’s hands. The next question is whether it can bring that same discipline to judgment, organization, and eventually to action itself.

Why this series

Crypto proved something essential long before most of the digital world was ready to hear it: when you can remove an opaque intermediary, you usually should.

That instinct gave us wallets, habits, slogans, and architectures. Over time it gave us something larger than tooling: a culture. Self-custody. Trust minimization. Resistance to capture. An insistence on clear permissions and visible points of control.

And yet something is shifting as AI becomes ordinary.

The same circles that learned to distrust intermediaries around assets are now increasingly willing to hand over their notes, reading habits, research workflows, contextual memory, preparatory judgments — and soon parts of their ability to act — to systems they do not fully understand and do not really control.

So the problem is no longer just data. It is delegation.

That is the real turn. Crypto already knows how to ask the right questions when money is involved: who controls what, who holds the keys, where the capture points sit, which trust assumptions are being accepted.

What remains uncertain is whether that rigor can be extended to thought, to organization, and to the conduct of action.

What these essays are after

We learned self-custody for assets.

We still have to learn it for judgment.

That is the thread running through these three pieces.

The first names the contradiction: we are not only living in the aftermath of Web2 and its empires of data. We are moving into a world where empires of delegation are beginning to take shape.

The second tries to recover a workable discipline. AI is no longer just an answer engine. It is becoming a work environment, a contextual memory, an organizational layer, and in some cases already a preparation for action.

The third explains why DeFi is one of the first places where this question can no longer be postponed. Sooner or later, every delegation shows up as a permission, a limit, a risk, or an architecture.

Edgar Morin is the quiet philosophical thread behind the series. Not as borrowed authority, but as a way of reading the moment: hold together autonomy and dependence, local power and systemic effects, genuine service and gradual dispossession. In other words, learn how to think in a complex environment without pretending that a local fix will settle the whole matter.

What this series does not promise

Not a universal stack. Not a new form of digital purity. Not a lazy indictment of AI.

It aims at something more useful: a way of telling apart what can be delegated, what should remain under direct control, and what we should now demand from the tools we let into our practice.

AI on Arem

Coherence is the scarce good

What becomes scarce

Aragon, the art of not governing

Twyne root-archetype, the grammar of agents

The missing layer

The false alternative

The natural slope

A political stake

To close

3. DeFi as a Laboratory of Delegation

In DeFi, an idea quickly turns into a permission, a risk rule, or a signature.

The protocol no longer sums up the system

What AI changes materially

Vibe coding: not a scandal, a reveal

Two protocols that make the problem legible

Money League: pushing the agentic horizon further

Polaris: returning to the question of constitution

What they show together

Morin: no local limit abolishes the systemic problem

Verifiability: a valuable aid, not a substitute for judgment

What this series was trying to show

2. Delegate Without Handing Yourself Over

The problem is no longer whether to use AI. The problem is how far to let it in.

Assistance, delegation, abandonment

The real test is ease

Where individual responsibility begins

What this second piece was trying to make practical

1. The Next Frontier of Self-Custody

We learned not to leave our assets with custodians. We have not yet learned not to hand our judgment too quickly to new intermediaries.

What has actually changed

A deeply crypto contradiction

The age of setups

Morin, or the useful bad news

The issue is not only the models. It is also the surrounding software.

What this first piece wanted to make visible

Intro: Self-Custody, But How Far?

Why this series

What these essays are after

What this series does not promise

The three pieces

1. The Next Frontier of Self-Custody

2. Delegate Without Handing Yourself Over

3. DeFi as a Laboratory of Delegation