An insight about the future that never became a specific bet. Lost conviction on a shakeout we should have bought the dip on. A group chat that shilled a token we ignored to our own demise. A stock we round-tripped because we lacked the discipline to sell. A great idea executed at the wrong size. If only I’d been faster to catch a liquidation. If only I’d come up with a real bet to my abstract idea. If only I’d bought when others were fearful and sold when they turned greedy.

We are all ready for our agents to make us rich. Every new LLM release triggers a flurry on X about how this is The One that will finally make you money. The space (broadly, Systems of Agency for trading) is being attacked from all sides. Public introduced Generated Assets in late 2025. Robinhood opened brokerage tooling to third-party agents in May 2026 and reached 150K+ agentic accounts by September. Coinbase extended its agent tooling to US equities in September. New products such as Supertake and Catalyst raised from firms like USV and Sequoia. The direction of travel is clear: today is the hardest it will ever be to get an agent deeply involved in your finances.

Beyond the hype, handing investing decisions to an agent is full of landmines. Models can already read filings, summarize calls, form a view, and propose a trade. Go into portfolio allocation decisions, or use an agent for long enough, and you’ll run into problems such as stale evidence, overtrading, bad portfolio construction, context blow-ups, or lack of awareness around nitty-gritty things like tax-lots and wash-sales.

Regardless of these difficulties, or perhaps because of them, this is a space we at BITKRAFT have been very curious about. We’ve had a front row to the rise of some important retail investing themes. For example, we are the only institutional investors in Roundhill Investments, the $30B+ thematic ETF manager behind the viral DRAM ETF; and, we’re the largest investors in StockGro, one of India’s largest subscription-based consumer apps, which is focused on providing stock insights and advisory through proprietary tools and RIAs, and recently filed for its IPO. Over the past year, as agentic finance took off, several of us started experimenting with these tools ourselves. We’ve built our own systems and personally experimented across prediction markets, crypto, perps and stocks. Along the way, we developed a view on what we think are some of the hard problems to solve.

Alex Danco has a useful lens for moments like this, from his Emergent Layers series: when something becomes abundant, look for what becomes scarce. Models have made analysis abundant. What has become scarce is trust: that the agent knows what is true right now, works on what the investor actually wants decided, and stays within its authority while proving what it did. Danco named trust as the next scarce resource back in 2016, and financial services as one of the industries organized around it.

Agentic investing covers a lot of different products. Most of what launched in the past year does one of four jobs.

Idea to portfolio. The investor has a belief (e.g., a power scarcity thesis) and the agent turns it into a set of positions, then watches and adjusts them. Public’s Generated Assets, Supertake, Catalyst and Glider work this way.

Signal to trade. The trigger is what other people do or say. The agent watches group chats, X accounts and wallets the investor can’t follow all day, and acts on what it sees. Virtuals’ Butler, for example, sits in the investor’s group chats and trades within a limit they set. Nansen’s AI trading works from its labelled wallet data.

Quant bots. The trigger is the price. The investor, or the agent reading the chart, has a view such as “BTC has support at $60K”, and the agent turns it into an entry, a stop, a target and a size. Scalar Field and most of the bots in Nof1’s Alpha Arena do this. D0, from BITKRAFT portfolio company Donut, pitches setups like this around the clock and places the order across spot, perps, Polymarket and DeFi once the investor says yes.

Portfolio management. The agent runs an allocation continuously within a mandate: rebalancing, harvesting losses, putting idle cash to work. Glider does this today from the investor’s own smart account. CoinFello extends the idea to any onchain position, from loans and yield to liquidity ranges. Many users still operate their own “systems” through episodic chats, spreadsheets and read-only APIs.

Each job can run with more or less authority. At one end the agent supplies information. Then it recommends. Then it completes a bounded action, with approval through an order execution layer. At the far end it runs a mandate continuously toward an objective.

The ten problems below are for an agent that acts on an investor’s money repeatedly over time, with some delegated authority. A single research question answered once avoids most of them. The problems fall into three groups, in order: does the agent know where the investor actually stands, does it know what the investor wants decided, and can it act within limits and prove what it did? A decision built on bad state is compromised at the start. A decision that does not bind to limits is unsafe to execute. Execution without a durable record cannot teach the system much afterward. After discussing these problems we give our view on where value may accrue, and we share a finance-focused memory kernel from one of us that addresses some of them.

We’re all querying the same models, trained on largely the same data and built to predict the most likely next token. That’s a tough setup for finding unique insights and tail (vs median) outcomes. Post-training with human feedback (RLHF) narrows the range even more (i.e., mode collapse). It’s unclear, but unlikely, that a general-purpose model can drive alpha vs beta.

An NBER working paper found that models’ daily picks lean toward big momentum names, follow the news, and earn no statistically significant abnormal return. Hallucination Yield asks eight models the same questions every week; at last count, at least five agreed on 7 of the 20 stocks it lists. As more people invest with LLMs, the average will show crowding effects, which can erode edge.

Getting away from the average takes judgement and biasing the model towards a narrower set of data that we deem more applicable. Take memory stocks: do low P/Es mean we’re at a cycle peak, like they have for decades, or has something changed? A model can argue either side well. Picking a side takes economics and market history, which the model doesn’t bring on its own (and where it brings “all of it,” without judgement, it’s not much more valuable than if it brought none of it). Cliff Asness of AQR calls most of the people building AI quant models today “suppliers not consumers of alpha for the foreseeable future.”

There are two ways to get that judgement in. One is context: feeding the model the investor’s own record, memos and data when it answers (i.e. retrieval-augmented generation, “RAG”), which is what most of this piece is about. The other is changing the weights. The large labs are mostly enhancing their general models with proprietary workflows and tools (e.g., paying bankers to teach them financial modeling). Others are building just for finance: Rogo fine-tunes OpenAI’s models, Fin-R1 uses reinforcement learning to teach financial reasoning, and Nof1 thinks frontier models need “purpose-built training” to trade. The catch is that you can’t open up weights to check or correct a view the way you can with a record, and if everyone trains on similar data, we’re back to the averaging problem one level up.

“What do you think of this stock?” can be answered from public information, though a good answer still depends on how deep the agent goes and the investor being explicit about what they care about. “Should I make this trade?” requires a current account of the investor: positions, cash, tax lots, concentration, pending orders, and exposure elsewhere in the book.

There is no single clock for those facts. Crypto trades through the weekend while listed equities do not. Take a weekend where crypto falls 10%. On Sunday night the agent sees a live crypto book next to Friday’s equity closes, concludes the portfolio is now underweight crypto, and plans to buy the dip by trimming equities at Monday’s open. But equities haven’t had their chance to react. If they open down too, the trim sells into the same drawdown, and much of the “underweight” came from comparing a Sunday price with a Friday one. Every number in the plan was accurate, just at different times. Fills and cash add the same problem on a smaller scale: two brokers can disagree about cash and positions for mundane operational reasons.

Tokenization could eventually put every asset on one clock, and demand is there: about 70% of trading in Robinhood’s stock tokens happens outside exchange hours. One clock needs liquidity and market makers behind it, though. Over the Labor Day weekend, Robinhood’s AMC token traded as high as $18.04 while the stock had closed at $2.54, and the gap closed only when premarket trading let arbitrageurs in. Until that depth exists, a weekend token price is a guess about Monday, and an agent should treat it as one.

Every fact the agent acts on needs a source and an as-of time. When a gap could change the trade, the right response is to reduce size, preserve room inside constraints, or wait.

The same goes for every number the agent produces. A stale mark changes a weight, a missing dividend changes a return, and a fee error changes the expected outcome of a trade. The risk is highest in a single headline figure such as expected return or portfolio upside. In one of our experiments, an expected-return figure changed across runs because it mixed scenario revisions, account snapshots and return bases. Each calculation was correct, but the inputs came from different places and times.

Systematic investors solved parts of this long ago with point-in-time data, source hierarchies and reconciliation. Agents need their own version: what must be live, what can be cached, and what happens when sources disagree. If a number can’t show where it came from, the agent should show the case behind it instead.

Agents can hold more and more context. Acting on it is harder. For example, an agent that can recite a prior semiconductor trim decision has demonstrated recall; an agent that uses a past trim decision when assessing the next AI-Infra position has demonstrated something more valuable. It’s the finance version of an open problem across AI, which researchers file under context rot and continual learning.

Retrieved memory is often just another paragraph in a prompt that the model can weigh against a fresher narrative, stronger phrasing or its own default instincts. A June 2026 benchmark of LLM portfolio agents (CLQT) had an independent model judge how well each agent’s allocations followed its own written analysis: 0.28 in a year-long backtest and 0.40 in live paper trading, on a scale of 0 to 1.

Corrections expose the same weakness. In our own experiments, a direct correction could supersede an earlier claim, but a later scheduled output could still use the old premise if it was in the compiled state summary. The correction was stored and linked to the claim it replaced, and the wrong answer still went out.

So the real question is what else has to change when a fact changes, and how fast, and through what process, that change makes it through the rest of the system. Old thesis work can inform judgement. Limits, corrections and execution state have to bind it.

Decision models such as TypeSafe’s Jev and OpenAI’s Decisions API may help, though we are still testing this: the language model proposes, a decision model checks the proposal against the mandate, and code enforces the result. Our kernel is built for that split. A decision model, or any model, can read a packet and say which rules apply and whether a draft meets them. Its answer is stored with its citations, a person accepts or rejects it with a receipt, and the mandate checks that gated approval stays in code, where no model can edit it.

Traditional software often fails visibly. Agentic systems can keep producing polished prose while a source has gone stale, a scheduled job has stopped, a model route has changed, or a retrieval path is quietly decaying. The output may remain readable long after the workflow has stopped being reliable.

Eloquence does not indicate that the system is healthy.

Catching this takes evidence. A serious agent should retain a receipt for the model that answered, the sources it used, the context it was given, and the controls that were applied. It should have known-answer tests for critical paths and freshness checks for information that can change a decision.

A good demo says little about whether systems remain good after a month of new data, new memories, new models and unattended jobs. It is a system-level cousin of catastrophic forgetting: nothing is retrained, yet new memories, prompts, and model versions can crowd out behavior that used to work. Reliability must be checked continuously.

“Thoughts on Nvidia?” may call for a quick view, a portfolio-fit analysis, a deep research memo, or a trade recommendation. “Add a little here” may be analysis, an instruction, or a request to prepare an order. The user often assumes the distinction is clear because the surrounding conversation is clear to them. The model, with lots of context and little guidance, will often misinterpret. Two investors with the same idea can also phrase it differently and get different answers.

The agent needs a disciplined ladder: quick take, ticker brief, portfolio fit, deep dive, formal thesis. The hard part is picking the right rung and noticing when ambiguity would change the decision.

The opposite failure is just as common. An explicit approval can disappear into another round of clarification if the system has no durable record of what was approved, for which account, at what size, and under what conditions. From the user’s perspective, the agent has stopped listening. Internally, the approval lived only as chat history.

Solutions can include hard triggers and agentic prompt clean-up. A phrase like “make a rule” or “never do X” has to create an actual rule that a separate control can check. A rule can never live in prose: the moment the investor says “rule” or “never,” the system should escalate. An intermediary agent can also rewrite the request into a standard form and ask clarifying questions upfront, so the same intent gets the same treatment however it was phrased. Once an instruction is clear, it should survive the path to execution without being re-litigated by a later component.

A research workflow can be fast, well sourced, and still fail at investing. The usual memo tours catalysts, risks, and valuation without identifying the few variables that determine the range of outcomes. For a memory-chip exposure, those may be hyperscaler capex, supply discipline, contract pricing, and the horizon over which each matters. Great investors see the forest and the trees; a great agent with all the context in the world often doesn’t.

Good research separates thesis, valuation, catalyst, and market setup. They are connected but they do different work. A durable company can be a poor trade at a particular price. A weaker company can be a good trade into a catalyst. The investor needs to know what is already reflected in the price, what would change the view, and which evidence would disconfirm it.

Research should be able to change an investment view. It should not be able to silently change the active underwriting. In one early build of ours, evidence ingestion and live valuation shared the same scenario state. A new filing then changed probabilities in the active model without a reviewed decision.

New information can create a proposed revision, with a before-and-after diff, provenance, and decision impact. A selected model revision should be explicit, immutable, and attributable to an authorized reviewer. Two more rules follow from the same idea. Research a model extracts should be a candidate until a person or a verifier checks the source, so a hallucinated filing cannot become evidence by being typed. And a trade proposed while a material question on the name is still open should be recorded as blocked, so the record shows whether the diligence was done before the decision or after it.

Portfolio construction and trading are as much about sizing risk as about picking the right investments. Most research queries stop at buy, hold, or watch. The next question is the investment question: how much?

Two investors can share the same thesis and make different trades because they own different things, face different tax constraints, or have different loss tolerance. Position sizing connects the thesis to the actual book. It requires a funding source, a risk budget, concentration limits, expected holding period, liquidity, transaction costs, and a plan for what makes the position grow, shrink, or close.

Ordinary retail details often matter most here. Tax lots, wash-sale risk, cash drag, and account location can move after-tax returns more than a marginal improvement in a stock screen. The agent also needs a view of the portfolio after the trade, checked against limits such as factor exposure and beta. An agent that recommends an idea without saying how it fits the portfolio has stopped one step short of an investment decision.

Sizing also has to look at the whole path. An entry, two adds to the position, a hedge and an exit can each be defensible and still add up to a strategy the investor would never have chosen. Each new order has to be judged by what it does to the position already held and to the initial plan.

Automation has a built-in preference for activity. There is always another catalyst, another price move, another model output that can support a trade. When recommendations cost almost nothing to generate, an agent keeps finding reasons to trade unless a rule tells it to wait.

Early public experiments point in the same direction. Short-horizon model trading contests, such as Nof1’s Alpha Arena, have shown extreme differences in turnover across models (in one, a model placed 238 trades to another’s 38 over the same two weeks), with costs explaining much of the underperformance. Inference is a cost too: in July, Nansen’s CEO said one of its trading agents had made $23 in profit while spending about $700 on inference. In one of our experiments, we traced ~95% of an agent’s negative PnL to fees, with a lot of overtrading from imperfect order execution. Humans have the same problem: Barber and Odean’s study of ~66K US households found the most active fifth earned 11.4% a year, against 17.9% for the market. Turnover has a cost, and an intelligent explanation is not evidence that a trade clears it.

Strong systems have restraint as a rule. A trade must clear an expected-edge threshold after spread, fees, tax, market impact, and the opportunity cost of capital. It also must fit a turnover budget. The system should record declined trades as carefully as accepted ones. A filter that blocks good trades along with bad ones has not shown value.

Incentives matter too. Some products earn from assets or idle cash: Wealthfront charges 0.25% a year, and net interest was 30% of Robinhood’s Q2 revenue. The agent products launched this fall earn mostly from order flow, subscriptions, and venue fees. An agent whose provider earns on every trade has no built-in reason to trade less. The business model does not dictate behavior, but it tells the investor where pressure may accumulate.

A good decision can still lose money between the order and the fill. Retail investors often point agents at thin markets they see as edgier: small caps, new tokens, prediction markets, perps at odd hours. A market order in a thin book pays the spread and moves the price. Speed matters as well: a deterministic bot reacts in milliseconds, while a model that reasons before each order can take seconds, long enough for a thin book to move away. A limit order may never fill, and a partial fill leaves the portfolio somewhere the plan never intended. Onchain, a pending order is visible before it lands and can be front-run. Across venues, the same asset trades at different prices and fees.

In the experiment where fees caused ~95% of our losses, much of the damage came from imperfect order execution. An agent needs an execution policy as explicit as its investment policy: which order types to use at which liquidity, the maximum slippage it accepts, what to do with a partial fill, and when to stop and ask. It should record the expected price next to every fill, so execution cost is measured trade by trade. Fills also get restated. A venue corrects a price or busts a trade after the fact, and the record should take that as a new receipt next to the original, with the busted fill dropping out of the position before anyone reconciles the book. Over time it should study its fills in aggregate. How the price moved in the minutes after each fill shows whether it is trading too fast or too slow, and a large order may need splitting over time or across venues to keep its own footprint small.

An agent that requires permission for every action adds little over a chat window. An agent with open-ended authority over capital is an unacceptable counterparty. The practical space is bounded authority: permitted assets, maximum size, approved venues, forbidden actions, time windows, and decisions that need a second signature. Robinhood segregates the agent’s account and lets users cap each trade. Supertake’s autopilot runs under a dollar limit. Catalyst asks a human to approve the plan. Virtuals’ Butler trades within a limit the user sets. CoinFello acts through a MetaMask delegation with spending limits, allowed tokens and an expiry date the user sets.

A rule can be written down, seen firing, or proven by actually blocking a bad trade. Prompts and task definitions only get you to the first. To get to the third, a separate control has to be able to stop the action and log why.

The location of enforcement determines who holds the mandate. Brokers have long enforced capital and compliance controls at the account. Onchain smart accounts can express narrow, revocable permissions: rebalance a specified allocation, within a stated limit, for a defined period, with no withdrawal authority. The enforcement boundary needs to sit where it cannot be bypassed by the model that wants to act.

An agent can follow instructions faithfully and still be a poor investor. It can make money through market beta, unintended factor exposure or luck, and it can avoid losses by declining every interesting decision. Returns alone cannot tell these apart. A credible evaluation tests the agent along the whole chain:

state → mandate → decision → execution → outcome → learning

The first test is consistency, and it is the cheapest. Run the same prompt on the same data many times and compare the decisions. In a 2025 study of five hosted models, each run ten times on identical inputs with settings meant to make the output repeatable, the authors found “accuracy variations of up to 15% across runs.” An agent whose trade changes from run to run on the same inputs is not ready for real money, and a simulator that replays past markets is the place to find that out.

The second is the record. Performance after costs is the floor, and a stronger test adjusts for market and factor exposure, turnover, drawdown and mandate adherence. That requires replaying what the model knew, what was current at the time, which constraints applied, who approved the action and what was actually executed.

The third is a baseline. The agent has to beat simpler systems, such as a deterministic bot, fewer rules, simpler signals or a narrower agent, after costs, turnover and its own failures. It also has to beat chance: run random strategies with the same turnover, and if the agent’s returns sit inside their range, they may be luck. If it fails either comparison, the extra machinery has not paid for itself.

The fourth applies to systems that learn. How much may the agent change on its own, and which changes need approval? A pre-defined strategy-tuning band is one answer: the agent adjusts inside it and asks outside it. When it does change something, can it show that the change worked, against what it would have done without it? And does it notice when an edge is fading, by tracking live results against the backtest that justified the strategy? A clean record answers none of these questions, since an agent can keep trading an edge that has stopped working and keep perfect records of it.

This is becoming a regulatory issue as well as an engineering one. FINRA’s 2026 oversight report, which asks firms to supervise agents specifically, and a June letter to the SEC from eight members of Congress with thirteen questions on agentic trading both point in the same direction: firms will have to own the behavior of systems that act for customers. Coinbase has already taken that step: Coinbase Advisor, launched in June, gives investment advice as an SEC-registered adviser, with the fiduciary duties that come with it. “The agent stayed within its mandate” cannot remain an untestable assertion.

The same discipline applies to builders describing their systems. “We store typed memory” is an architecture claim. “Our memory improves investment decisions” is an outcome claim. The latter needs a dated evaluation against a clear baseline. We are publishing the record model behind our own work as a finance memory kernel with synthetic data. It addresses the record and revision layer, and gives a judgment model a slot with no authority. It does not claim to solve judgement or enforcement, yet.

We see four layers in the stack: data and its sources, decision and model primitives, the investor record, and venues or accounts. The contested layer is the investor record: mandate, memory, approvals, constraints, and decision history.

Danco’s lens applies to the stack as well. Agents make the app abundant: if an agent can place the trade, the screen it used to happen on matters less. The trade itself stays scarce. It has to execute somewhere, and today it can only execute where the investor’s assets already sit. The agent abstracts the app. Custody keeps the trade. That is why brokers start with a real advantage, and why Robinhood and Coinbase are racing to hold every asset class in one account and to host agents inside it.

Where custody becomes portable, execution becomes a commodity and the money moves to whoever holds the mandate. Onchain is where this is happening first. Glider and CoinFello, both BITKRAFT portfolio companies, already let agents act without taking custody: Glider runs portfolios from the investor’s own smart account, and CoinFello runs strategies through a revocable MetaMask delegation. The amounts are still small: DeFiLlama tracks under $40M in agent-managed DeFi deposits, up about $10M last quarter according to Cambrian’s October report. Traditional accounts will follow more slowly, as agents that work across brokers make execution prices easy to compare and switching cheaper.

That assumes the platforms let agents in. Agentic commerce had a jagged start: shortly after launch, Meta’s Muse was being blocked by Amazon. Banking is further down the same road. In late September, Apollo’s Torsten Slok asked whether an agentic bank run is coming: agents that move household cash from checking accounts paying close to nothing into accounts paying 3% to 5% would drain the cheap deposits banks lend against. By mid-October, Citi had barred third-party agents from logging in or transacting, Bank of America limited agents’ access to deposits until it knows who is liable for a payment an agent authorizes, Schwab said it was blocking unauthorized agents that try to move client money, and Jamie Dimon told JPMorgan’s earnings call that “you don’t want rogue agents, and there could be thousands of them.” An agent that moves cash to the best rate is good for the customer and bad for the bank, so the bank blocks it. A broker that earns on order flow faces the same choice with a trading agent, which is one more reason it matters who holds the permission.

Data is going the same way. As agents crawl all public data, it loses its edge, and what stays scarce is proprietary data in a form agents can use. FactSet, LSEG and Bloomberg have all opened their data to agents in the past year, and Nansen and Kaito sell crypto datasets the same way. The most proprietary dataset an agent will touch, though, is the investor’s own record, which brings the question back to who holds it.

Independent products have a credible reason to exist where an investor works across venues, assets, and accounts, or where a portable record creates continuity that a single broker cannot provide. Supertake is betting on a public, forkable thesis with a visible track record; Catalyst on an intent that routes across venues; home-built agents like ours on a record the investor writes and runs. Strategies themselves are becoming products: Glider users can copy each other’s portfolios, and CoinFello is building a marketplace where creators earn when others run their strategies. If creators are paid per use, they are paid for activity, which brings back the incentive problem from Problem 7. A record that does not alter decisions has little switching cost. A record that reliably carries the investor’s history, current mandate, and controls is hard to walk away from.

We expect the clearest near-term economics to remain close to execution, settlement, risk, and liquidity. Meanwhile, context and decision tools may set products apart well before anyone figures out how to charge for them.

Take the three “if only”s we started with. The first was speed, and agents already fix it: they are fast, they read everything, and they don’t sleep through a weekend move. They are getting better at the second, because turning an abstract idea into a tangible bet is research, and models are good at research.

The last one is different. Buying when others are fearful and selling when they turn greedy is a discipline problem, and discipline is exactly what today’s agents lack. They forget rules, overtrade, and drift while still sounding sure of themselves. The agent that finally makes us rich will probably be the one that remembers what we decided, does less than it could, and can show us why.

That is the system we have been trying to build for ourselves with the finance memory kernel. This is a small reference implementation of the investor record. A model cannot write evidence - it extracts a candidate, until a person or a verifier promotes it. Every claim carries a source and the time it was observed. Corrections supersede without erasing, and anything that rested on the corrected claim is flagged until someone refreshes it. New evidence can only propose a revision which a human then enshrines. Every trade is checked against the investor’s mandate and against the diligence still open on the name, and moves from proposal to approval to execution only with a receipt. The model cannot approve its own trade, close its own open questions, or waive a check. A venue correction or bust appends to the fill; nothing already written changes. Most of these rules are enforced by the database itself. It runs on Python and SQLite with synthetic data and it’s there for you to fork it, break it, and tell us where it’s wrong.

We are most interested in agents with judgement: systems that hold a large and growing context, use it well over months and years, and earn more authority as they prove they deserve it. Most products today start from a single thesis or a single trade. The scarce thing is an agent you would still trust after a year of use. If you are building toward that, at any layer, we’d like to hear from you.

BITKRAFT and/or its affiliated funds are investors in certain companies discussed in this article and therefore have a financial interest in those companies. References to these companies are included for informational and illustrative purposes only and should not be viewed as a recommendation, offer, or solicitation to buy or sell any security or investment product. Nothing in this article constitutes investment advice.

Roundhill Investments. A US ETF issuer with over $30B under management across thematic, income and leveraged funds. Its Memory ETF (DRAM), launched in April 2026, is the fastest-growing ETF on record: it took in nearly $10B in 43 days and passed $20B within 11 weeks, beating the prior velocity records set by BlackRock’s IBIT. BITKRAFT is Roundhill’s only institutional investor.

StockGro. An Indian stock market advisory and research app with 45M active users, who get trade ideas and AI-assisted research from more than 150 SEBI-registered analysts and can follow experts’ verified portfolios. Its parent, AssetGro Fintech, confidentially filed for an IPO with SEBI in September 2026.

Glider. An automated investing app used by more than 100K investors. It runs a user’s strategy across any onchain asset and rebalances without ever holding the user’s money. A strategy can be a broad-market portfolio of tokenized S&P 500 shares or an actively managed mix of stocks, crypto and stablecoins. Investors can build their own or copy ones others share. It powers Bitwise’s Automated Token Portfolios (ATPs), launched with Coinbase in August 2026. Glider users’ accounts together make it the largest holder of Coinbase’s tokenized stocks.

Donut. Builder of D0, a trading agent that watches markets around the clock, proposes setups and executes across spot, perps, prediction markets and DeFi. Investors talk to it in plain language through Telegram, a dashboard, a command line or voice.

CoinFello. Built by the team behind HyperPlay, CoinFello is a crypto agent that researches, executes and automates almost anything onchain, from swaps and bridging to loans, yield and liquidity positions, from the user’s own wallet. It acts through a revocable MetaMask delegation with spending limits, allowed tokens and expiry dates the user sets.