The strategy layer of finance.

Joint-stock companies pooled capital across investors. Electronic trading systems digitized execution. Programmable blockchains introduced the first credible alternative to institutional custody of assets. Bitcoin demonstrated that value could be held and transferred without centralized intermediaries. Ethereum extended this by introducing programmable smart contracts.

Collectively, in a cascade, these innovations transformed the custody and transfer of capital. However, one critical layer of financial infrastructure remained largely unchanged: strategy.

Financial strategy — the process by which signals are interpreted, risk is managed, and capital is deployed — has historically required institutions to coordinate. Asset managers, hedge funds, and trading firms exist primarily to perform this function. They translate investor intent into structured strategies and execution systems.

As programmable financial infrastructure expands, the complexity of coordinating strategy across markets increases. Participants must manage interactions across multiple assets, venues, and signals. The need for systematic coordination grows.

This paper introduces the Agentic Finance Operating System (AFOS) — a framework designed to coordinate financial strategies through programmable infrastructure. AFOS translates user intent into composable strategy graphs capable of executing autonomously across financial markets. These strategies operate through persistent automation primitives known as daemons, which monitor signals, manage state, and trigger financial actions when predefined dependencies are satisfied.

By transforming financial strategies into composable software systems, AFOS introduces a new paradigm: rather than delegating capital to institutions, individuals deploy capital through programmable strategies that operate continuously.

This transition represents a shift from Assets Under Management to Assets Under Autonomy. If custody is decentralized and strategy becomes programmable, the traditional structure of financial intermediation begins to dissolve. Capital becomes not merely stored or transferred but continuously deployed through autonomous strategy systems.

The implications extend beyond decentralized finance. They suggest a broader transformation in how individuals interact with economic systems. Strategy becomes infrastructure. And finance becomes software.

In December of 2024, two pieces of work made a deep impression on me. The first was research by Joon Sung Park and collaborators on generative AI agents operating in simulated environments — how autonomous agents could inhabit persistent worlds, form alliances, pursue goals, and evolve behavior through interaction. The second was Situational Awareness: The Decade Ahead by Leopold Aschenbrenner: a ~165-page document examining the coming decade of AI through the lens of geopolitical competition.

At first glance these works seemed unrelated. One examined agents operating inside simulated environments. The other examined agents operating inside geopolitical systems. But together they highlighted something that, once seen, felt obvious: the world increasingly behaves like systems of agents interacting inside constrained environments.

Financial markets are perhaps the most sophisticated example of such a system. Millions of actors interact continuously through capital, responding to signals, pursuing strategies, and competing for resources. Markets are not static — they are evolving ecosystems of agents, and the strategies those agents deploy determine how capital flows.

From identity to action

Much of my earlier work in the crypto ecosystem revolved around identity — through projects like Root Protocol, which explored decentralized identifiers and user-controlled frameworks. Identity systems answer a fundamental question: who has the authority to act within a system?

But identity alone is not enough. Once identity is established, a second question emerges. How do individuals act? Identity determines who can participate. Strategy determines how they participate.

The ParaHell experiment

By late 2023 and into 2024, my co-founder Jay Nasr and I began working on an experimental system called paraHell — a play on the word parallel. Players could spawn agents into a persistent world and influence them through prompts. Agents had a small set of primitive actions: ally, hide, hunt, betray. Players funded agents with stablecoins, and after a fixed period the world reset. Pooled capital would be distributed to the winning agents.

It looked like a hybrid between Fortnite, GTA, and an agent simulation. But when you stripped away the visuals and game mechanics, what remained was a system that looked remarkably similar to global markets. Agents competing inside a constrained environment. Agents forming alliances and rivalries. Agents pursuing strategies to accumulate resources.

Replace weapons with financial strategies and resources with capital, and the analogy becomes obvious.

A simpler suggestion

Our third co-founder, Maxim Sindall, suggested something that initially felt almost too simple. Instead of building a complex agent simulation, why not start with something more practical? Why not let people trade through natural language?

At the time, navigating decentralized finance was still extremely complex. Users had to manage multiple wallets, multiple chains, multiple protocols. Meanwhile, the concept of intents was beginning to emerge as an important abstraction: rather than forcing users to construct transactions manually, intent-based systems let users specify the outcome they want and the system determines how to execute it.

Seeing the larger problem

When we began experimenting with early versions of Kuvi — linking natural language instructions to swaps, trades, and event-based triggers — we realized we were standing at the foothills of a much larger problem. We were not building a trading interface. We were building the early infrastructure for programmable strategy.

Bitcoin decentralized money. Ethereum decentralized custody. Stablecoins stabilized value transfer. But the logic that determines how capital moves through markets — strategy — remained institutional.

The North Star

Each founder brings a different perspective. Jay approaches problems with deep technical rigor. Maxim brings strong instincts for usability and narrative. My own perspective has been shaped by years working in systems that attempt to remove structural dependencies on institutions. But we share a common north star: to make strategy programmable. To remove the structural barriers that historically restricted sophisticated financial coordination to institutions. To allow individuals to compose, deploy, and evolve financial strategies without gatekeepers.

Ethereum made finance programmable. Kuvi makes strategy programmable. If programmable money was the first revolution of crypto, programmable strategy may be the last.

Capital itself is abundant. Global financial assets exceed half a quadrillion dollars. Markets exist for every conceivable asset class, from government bonds to weather derivatives. Execution infrastructure has been steadily commoditized. Yet the ability to design and coordinate financial strategy remains concentrated inside a relatively small number of institutions: banks, hedge funds, and various types of asset managers.

These institutions are often described as custodians of wealth or intermediaries of capital. But this description misses their true role. Their real function is much simpler: they translate intent into strategy.

An investor expresses a goal — generate yield, protect capital, gain exposure to new markets. Financial institutions translate those intentions into structured systems: portfolio allocations, trading algorithms, risk management frameworks, execution pipelines. This translation layer — between human intent and market execution — has historically required enormous infrastructure. Teams of analysts. Trading systems operating across multiple markets. Continuous monitoring and risk management.

In short, the infrastructure of strategy composition. Individuals may own capital. But institutions control the mechanisms by which capital is deployed.

The first crack

The emergence of programmable blockchains introduced the first structural break in this system. Historically, financial assets were held through chains of institutional intermediaries: investor → broker → custodian → clearinghouse. Each layer introduced friction, dependency, and systemic risk.

Ethereum collapsed this chain into cryptographic ownership: investor → private key. For the first time in history, individuals could hold and control capital directly. Smart contracts extended the model: capital could be deployed programmatically into decentralized exchanges, lending protocols, derivatives, liquidity pools.

Ethereum made finance programmable. This was revolutionary. But custody alone does not replace financial institutions. Because custody is not where financial complexity lives. The real complexity lies elsewhere — not in holding capital, but in deploying it intelligently.

Ethereum decentralized custody. Kuvi decentralizes strategy.

The limits of prediction

Financial markets are often treated as prediction problems. This assumption is incorrect. Markets are not deterministic systems — they are complex adaptive systems composed of millions of interacting agents. Their dynamics exhibit nonlinear feedback loops, reflexive behavior, adversarial optimization, and incomplete information. In mathematical terms, markets behave similarly to chaotic systems: small variations in initial conditions produce exponentially diverging outcomes.

Financial markets exhibit precisely this behavior. Even perfect knowledge of the present cannot produce reliable forecasts of the future. Successful financial systems do not rely on prediction alone. Instead, they rely on structured responses to signals.

Strategy as software

Across centuries of trading, most successful strategies fall into a small number of archetypes: momentum, mean reversion, arbitrage, event-driven, market making, relative value, volatility. These are not individual strategies — they are strategy primitives. Most sophisticated trading systems simply combine them. The strategy space grows combinatorially as signals and execution venues increase. Human cognition cannot navigate this space effectively. Professional trading firms solve this through immense infrastructure. Individuals cannot.

Which brings us to the central question: what happens when strategy becomes programmable?

AFOS is a coordination system that translates human financial intent into structured, persistent execution processes. At a high level, it performs five functions.

Daemons · the primitive of financial automation

Daemons are the fundamental execution unit within AFOS. Unlike scripts or trading bots, daemons are not temporary. They exist as long-lived financial processes with four defining properties:

• Stateful — they maintain internal state over time
• Persistent — they operate continuously, without supervision
• Referenceable — they can be addressed by other daemons
• Triggerable — they can activate other processes downstream

Each daemon performs a specialized function within the strategy graph. Strategies therefore become software systems rather than temporary trading scripts.

Time-to-execution advantage

In many financial systems — particularly event-driven markets — the difference between profit and loss is measured in seconds. A typical event-driven trade requires signal detection, human interpretation, strategy evaluation, manual execution. Each step introduces latency.

AFOS collapses this pipeline. Because strategies exist as persistent financial processes, the strategy is already running when the event occurs. Signals detected by daemons trigger execution immediately. For event-driven strategies based on social signals, prediction markets, or macro announcements, this advantage can be decisive.

Deterministic execution

AFOS separates decision interpretation from execution logic. Natural language interpretation occurs only at the intent stage. Once the execution graph is constructed, all operations are deterministic. This ensures strategies remain auditable, execution remains predictable, and capital is protected from model hallucinations.

AFOS does not merely automate execution. It reduces time-to-decision and time-to-execution simultaneously.

A financial strategy generates profit when it exploits a persistent structural pattern — behavioral biases, structural inefficiencies, latency differences, information asymmetry, liquidity imbalances. Momentum strategies exploit delayed information diffusion. Arbitrage exploits price discrepancies. Market-making exploits bid-ask spreads. Each generates statistical edge: E[R] > 0.

However, markets are adaptive. As profitable strategies are discovered, capital flows toward them. This gradually erodes the original edge.

Professional trading firms address this through constant experimentation. Large quantitative funds employ hundreds of researchers to continuously develop new strategies to replace decaying ones. This infrastructure barrier historically prevented individuals from participating in strategy discovery. Kuvi addresses this by dramatically lowering the cost of experimentation — users modify existing strategy graphs rather than building entire trading systems from scratch.

Combinatorial strategy space

The power of composability arises from combinatorial growth. If a system contains N primitives, the number of possible strategies grows approximately as O(2^N). Even modest growth in primitive count dramatically expands the strategy space.

Strategy markets & the creator economy of strategy

As the ecosystem grows, a natural division of roles emerges. Strategists design and refine strategies — their objective is to identify patterns before they become crowded. Allocators deploy capital into strategies with favorable expected returns. Infrastructure providers maintain execution systems and integrations. These roles mirror traditional finance, but AFOS coordinates them through software rather than institutions.

In digital ecosystems, a small fraction of creators produce content consumed by a much larger audience. Strategy ecosystems are likely to follow a similar pattern — a relatively small number of strategists may produce strategies deployed by large pools of capital.

The library effect

As strategies are constructed, the number of reusable primitives grows. Each new strategy may introduce new components — signal processors, execution modules, risk filters, monitoring systems. Over time, the strategy library expands, producing a compounding effect familiar to anyone who has watched operating systems, cloud infrastructure, or open source ecosystems grow:

This is the library effect — one of the primary drivers of growth in software ecosystems, now applied to financial strategy.

AI-driven trading bots frequently operate as opaque black boxes. Users cannot easily determine when a trade will occur, why it will occur, whether sufficient capital exists, or whether execution conditions are satisfied. Kuvi addresses these concerns through a deterministic, non-custodial execution model.

AFOS does not custody user funds. Capital remains under the control of user-owned wallets. Execution occurs through smart contracts that act as conditional execution environments rather than custodial vaults. Each user is assigned a dedicated strategy contract:

The strategy contract coordinates daemon execution while ensuring capital remains under user control. Kuvi never assumes discretionary custody of funds.

Dependency-based execution

Each daemon contains explicit dependency conditions. Execution occurs only when event conditions, risk conditions, and capital conditions all evaluate as true. If the user originally allocated $1000 USDC but later moved the funds elsewhere, the trade simply cannot execute. The strategy remains active but dormant. Capital itself acts as a dependency within the execution graph.

Strategy state & transparency

Because strategies operate through smart contracts and explicit execution graphs, their behavior can be inspected. Users can observe daemon dependencies, trigger conditions, execution history, capital allocation. Strategies are not opaque models — they are explicit computational processes.

Under AUM, individuals entrust capital to institutions that coordinate financial strategy on their behalf. Asset managers decide where capital should be allocated, when positions should be entered, how risk should be managed, when strategies should be exited. The investor delegates decision-making authority to the institution.

This delegation has historically been necessary because strategy execution required infrastructure individuals could not easily access: research teams, trading systems, monitoring frameworks, operational scaffolding. These requirements created the institutional structure of modern finance.

But blockchains made custody programmable. And AFOS makes strategy programmable. Once both layers become programmable, the institutional coordination layer becomes unnecessary. Capital no longer needs to be managed. It can be deployed autonomously.

Capital as a computational resource

Under AUA, capital behaves less like a passive asset and more like a computational resource. Just as operating systems allocate CPU cycles to processes, AFOS allocates capital to strategies. Capital becomes an input into programmable systems. Strategies become the processes through which capital flows. These processes operate continuously — they monitor signals, evaluate conditions, deploy capital when opportunities emerge. Capital no longer sits idle. It becomes active.

Four stages of financial evolution

• Custodial Finance — capital held by institutions
• Electronic Finance — markets accessed through digital infrastructure
• Programmable Finance — capital deployed through smart contracts
• Autonomous Finance — capital deployed through programmable strategies

AFOS represents the transition into the final stage. If strategy becomes programmable infrastructure, the structure of finance changes fundamentally. Financial institutions historically existed because individuals could not coordinate complex strategies themselves. When strategy becomes software, this coordination problem disappears.