Why We Built the Hyperliquid Agents Runtime - the Layer Between the Agent and the Chain

We just shipped the Senpi Hyperliquid Agents Runtime - the layer between the agent and the chain.

Here's what we learned from $230M+ in agent trading volume and running 44 autonomous trading agents with $1K each on Hyperliquid x OpenClaw: the data layer plus the runtime is the moat.

The signal was never the problem

Senpi's Hyperfeed tracks the top 1,000 traders on Hyperliquid in realtime. Every position, every P&L move, every concentration shift - enriched and served through our MCP to any agent that connects. We built 40+ trading skills on top of this data: momentum scanners, contribution velocity detectors, squeeze finders, single-asset lifecycle hunters, multi-asset thesis pickers, even a strategy that counter-trades degens who are bleeding out at high leverage.

The agents are good at entries. Our ETH hunter (Polar) consistently identifies high-conviction setups when smart money commits 80%+ in one direction. Our contribution velocity scanner (Phoenix) found a HYPE SHORT at 54x divergence ratio - SM profit concentration was surging while price was completely flat. That trade peaked at +50% ROE and realized +$101 profit on a $200 position.

The signals work. Hyperfeed is the edge. We were right about the data layer.

What needed improvement: agent execution.

Where agents make mistakes

We deployed 40+ agents across BTC, ETH, SOL, HYPE, and 54 XYZ equity assets on Hyperliquid. Each agent had its own scanner (the entry logic) and its own DSL script (the exit logic) - a Python cron running every 3 minutes, writing state to JSON files, placing stop-loss orders on the exchange.

What agents did next with it was less than perfect.

State files got corrupted. The exit script writes a JSON file with the wallet address, position size, trailing stop parameters, and high-water marks. When a cron died mid-write or the gateway restarted, the file either vanished or wrote incomplete data. Nine agents lost their wallet address field. Combined losses from unprotected positions: over $3,000.

Agents second-guessed themselves. We built thesis-exit logic into the scanners - if the market conditions that triggered the entry shifted, the scanner would close the position early. Sounds smart. In practice, the scanner would re-evaluate every 3 minutes, get spooked by a minor pullback, and scratch a profitable trade at +0.35% ROE that would have run to +20%. Same market, same agent - the only difference was who controlled the exit.

Two exit paths fought each other. The scanner thought it should manage exits. The stop-loss script thought it should manage exits. Both trying to close the same position meant race conditions, duplicate orders, and confusion.

Crons died and nobody noticed. The exit script runs every 3 minutes. When it crashes, there's no alert. Positions sit on the exchange with no protection. We found one agent's exit logic had been dead for 10+ hours. The position ran completely naked.

Agents told us everything was fine when it wasn't. When we asked an agent "is your stop-loss running?", it checked its state file, saw "status: running," and said yes. The state file was tracking the wrong wallet. Zero protection. The agent didn't know because it was reading stale data instead of checking the chain.

Every one of these failures has the same root cause: exit management was in the hands of the agent. Each agent maintaining its own crons, its own state files, its own exit logic. Multiply that by 40+ agents and the failure surface is enormous.

The insight

Entries require intelligence - reading the market, synthesizing signals, making probabilistic decisions. That's what LLMs are good at.

Exits require reliability - track the price, compute the trailing stop, enforce the floor, close when breached. Every 30 seconds, without fail. No hallucinations. No lost state. No silent failures.

We were asking agents to do both. Different jobs. Different reliability requirements. The answer was obvious once we saw it: make exits infrastructure.

What we built

The Senpi Hyperliquid Agents Runtime is the layer between the agent and the chain. It takes critical trading infrastructure out of the hands of individual agents and LLMs, making it work uniformly across every agent - increasing reliability and lowering token consumption.

The first module: the DSL (Dynamic Stop-Loss) plugin.

Automatic onchain position detection. The runtime polls the wallet every 10 seconds. When a position appears - whether opened by an agent, manually on the exchange, or by any other tool - the DSL immediately starts protecting it. Zero configuration per position.

2-phase trailing exit system. Phase 1 protects from entry: hard loss floor, trailing retrace, consecutive breach confirmation to survive wicks. Phase 2 locks profits: dynamic tiers that tighten as the position runs. The floor only goes up, never down.

30-second monitoring. Not 3-minute cron cycles. Exchange stop-loss orders synced to the Hyperliquid order book as a safety net against flash crashes.

One YAML config. Install a runtime, point it at a wallet, define your DSL parameters. Every position on that wallet is protected.

Also shipping in this release:

Auto-upgrades. As we ship enhancements, agents automatically get them. No manual intervention, no version drift across dozens of agents.

Health checks. Common infrastructure for agents to run diagnostics and self-heal. openclaw senpi status gives an honest answer about whether the runtime is healthy - no more trusting agent self-reports.

What changed instantly

The data from our fleet tells the story.

Before the runtime:

• Polar (ETH): positions held 2 minutes, scratched at +0.35% by the scanner's thesis exit

• Phoenix (HYPE): best signal in the fleet, but infrastructure failures cost -25% on a single unprotected position

• Nine agents lost wallet fields - $4,000+ in unprotected losses

• Mantis: -44% ROE from a re-entry loop where the scanner kept opening positions the exit script kept closing

After the runtime:

• Polar (ETH): +19.8% and +18.4% ROE on back-to-back trades, both reaching Phase 2 Tier 3, trailed and exited in profit

• Positions holding 20-30 minutes instead of 2

• Zero state file corruption

• Zero silent failures

Same agents. Same signals. Same market. The only change was moving exit management from the agent to the infrastructure.

The thesis

AI models are a commodity. GPT-4, Claude, Gemini, open-source fine-tunes - the gap narrows every quarter. Every team building trading agents has access to roughly the same reasoning capability. Table stakes.

Skills are open source. Our entire trading skills zoo - 40+ strategies - is open source on GitHub. Anyone can fork them, modify them, build new ones. We made this choice deliberately. The more strategies on the platform, the more valuable the layers beneath them become.

The proprietary data layer is the edge. Hyperfeed tracks the top 1,000 Hyperliquid traders in realtime - contribution velocity, momentum events, trader quality scores, concentration analysis. Everyone will have agents. Not everyone will have the data to feed them.

The hardened runtime is the moat. Agents come and go. Strategies get invented and deprecated. Models get replaced. The infrastructure all agents depend on - position tracking, exit management, risk enforcement, health monitoring - that compounds. Every bug we fix, every edge case we handle benefits every agent on the platform simultaneously.

What's next

DSL is the first runtime module. The roadmap:

Risk enforcement. Portfolio-level rules no individual agent can override. Daily loss limits, max exposure, max leverage. The runtime blocks violations before they reach the chain.

Position tracking as a platform service. Every strategy wallet monitored automatically. Real-time P&L, trade history, performance attribution - read from the chain, not computed by agents.

Strategy health monitoring. Not "is the cron running?" but "is this strategy actually working?" Automated detection of agents that are churning, bleeding fees, or diverging from their intended behavior.

Onchain stop losses. Moving trailing stop logic to Hyperliquid's native execution layer - eliminating the monitoring gap entirely.

Hyperfeed, Hyperfeed, Hyperfeed. More and more enriched realtime Hyperliquid data for agents to generate alpha strategies from.

AI models are a commodity. Skills are open source. Everyone will have agents.

The proprietary data layer that feeds them and the hardened runtime that executes for them - that's what compounds. That's the moat.

Live now at senpi.ai.