1. Why Build a Bot Portfolio Instead of One Strategy
Relying on a single bot (or strategy) is brittle. Market regimes shift, token behavior diverges, and what works in one pair may tank in another. A portfolio of bots spreads risk, captures cross-token alpha, and allows you to adapt to changing conditions.
Benefits:
- Diversification: Some bots win when others lose
- Cross-token insights: Behaviors in one token feed signals into others
- Capital efficiency: You can dynamically reallocate capital among bots
- Resilience: A single strategy failure doesn’t wipe you out
In short: trading smarter means building modular bots you can orchestrate—not betting everything on one script.
2. Choosing “Top Tokens” on Hyperliquid
You need target tokens for your bots. Here’s how to pick:
Criteria for Top Tokens
1. Liquidity & Volume: Ensure spreads are tight and slippage low
2. Volatility: Enough movement to enable edge (but not explosive risk)
3. Ecosystem relevance: Projects with traction, community, or utility
4. Listing stability: Tokens that are consistently tradable, not ephemeral
Examples of Top Hyperliquid Tokens
Based on Hyperliquid ecosystem listings and token data sources:
HYPE (Hyperliquid’s native token) — flagship & often heavily traded
PURR (Purr) — a meme/community token with trading activity
HFUN (Hypurr Fun) — speculative token listed on the Hyperliquid ecosystem maps
PIP — smaller but active token in the Hyperliquid ecosystem listings
RAGE / FARM / BUDDY — occasional tokens or meme picks listed in the exchange markets
By selecting 4 to 6 such tokens, you can launch parallel bots that each approach the same or different strategies.
3. Architecture & Execution Stack: Coinrule + Hyperliquid + limits.trade
To run a bot portfolio, you need a reliable stack:
Hyperliquid provides the on-chain perpetual infrastructure—fast matching, gasless order layer, and low-latency execution.
Coinrule is your automation and orchestration layer: you define IF/THEN rules per bot.
limits.trade is the execution primitive: placing adaptive maker-only orders with chase / replace logic.
Flow:
1. A specific bot’s rule triggers on a token (e.g., HFUN)
2. Coinrule sends a signed order instruction via limits.trade
3. Hyperliquid executes or replaces the maker limit, responds to fills or cancellations
4. Coinrule monitors and triggers exits, adjustments, or scaling
This stack ensures non-custodial, modular, and reactive bot behavior across tokens.
4. Rule Templates & Structure for a Bot Portfolio
Here is how to structure your bots in Coinrule.
Common Template Outline
Each bot should follow a modular template:
1. Entry Conditions
Signal: moving average crossover, breakout, cluster, volume surge
Filter: spread, volatility, liquidity threshold
2. Execute Entry
Action: place limits.trade maker limit order, with buffer / replace logic
3. Exit Conditions
Stop-loss: e.g. –X%
Take-profit: e.g. +Y%
Trailing stop: follow best price
4. Risk / Safety Rules
Max position/leverage caps
Timeout/replacement limit
Cancel orders on low liquidity / high volatility
5. Scaling / Adjustment
Partial adds or scale-outs
Rebalance across bots
You replicate this template per bot, changing parameters (token, signal algorithm, buffer, thresholds) but maintaining structure.
Example JSON‑style Pseudocode for “PURR Momentum Bot”
Rule “PURR Momentum Entry”:
IF PURR price > SMA100 AND volume > X AND spread < Smax
THEN limits.trade maker buy PURR size = 2% equity with chase buffer 0.3%
Rule “PURR Exit / Stop”:
IF PURR price < entry_price * (1 – 0.03)
THEN exit position
Rule “PURR Target / Trailing Exit”:
IF PURR price > entry_price * (1 + 0.05)
THEN place a trailing exit or partial sell
Risk / Safety settings:
– Max replacements = 5
– Replace buffer = 0.2%
– Suspend bot if volatility (ATR) > threshold
– Cap position size to 5% of portfolio
You’d create equivalent rules for HYPE, HFUN, etc.
5. Risk Management Across the Bot Portfolio
Managing risk is more complex when many bots run concurrently.
Portfolio-Level Risk Rules
Total exposure cap: ensure the sum of open positions ≤ e.g., 20% of capital
Correlation management: avoid all bots going in the same direction during regime shifts
Max drawdown rule: if cumulative drawdown > X%, pause all bots
Buffer capital reserve: never invest 100%, keep safety funds
Inter-Bot Safeguards
If one bot fails (e.g., gets stuck on orders), it should not drag others
Use “cooldown” logic: a bot deactivates for a period after a big loss
Use replacement caps to prevent runaway cancel-replace sequences
Each bot should also independently carry internal risk rules (stop-loss, timeouts, etc.).
6. Monitoring, Metrics & Analytics
To operate a bot portfolio meaningfully, you need to track:
- Fill Rate vs Replacement Count per bot
- Win Rate & PnL per Trade
- Slippage & Gap Loss (difference between your limit and executed price)
- Time in Market (how long capital is tied up)
- Drawdown curves per bot/portfolio
- Correlation & Alpha Attribution (which bots drive returns)
- Latency / RPC errors and rule misfires
Use dashboards, alerts, or custom sheets to surface irregular patterns. If a bot underperforms, you should be able to pause it quickly.
7. Scaling & Capital Allocation Dynamics
Once a few bots work, scaling is an art.
Incremental Scaling
Raise capital for the best-performing bots first
Use ratios based on Sharpe / risk-adjusted return
Rotational Allocation
Periodically rotate capital away from underperformers into stronger bots
Use trailing signals or performance momentum to reallocate
Bot Lifecycle Management
Periodically retire or evolve bots that stagnate
Introduce new tokens or strategies gradually
Test new bots in sandbox mode before live deployment
Your capital allocation logic should be part of your automation system.
8. Dealing with Slippage, Latency & Order Replacement
These are the execution frictions you must engineer around.
Buffer margins: always set your chase / replace buffer generously (e.g. ±0.2–0.5%) to allow for micro drift
Replacement caps: limit the number of cancel → reissue cycles to avoid over-churn
Cancel-first logic: Hyperliquid supports cancel-first to prevent being picked off mid-update
Simulate latency: embed expected RPC / chain delay metrics into thresholds
Partial fills handling: if only part of your order fills, logic should scale or adjust the remainder
Trading in a bot portfolio needs careful permissioning on how aggressively rules chase the market.
9. Backtesting & Iteration Workflow
Even with live bots, you should always test new strategies and validate performance under simulated conditions.
Steps:
1. Historical data: gather price, volume, and orderbook snapshots for each token
2. Simulated bot execution: run your rules offline, compute fills, slippage, PnL
3. Stress test: test drug cycles, volatility spikes, sudden price gaps
4. Parameter sweep: test buffer sizes, thresholds, replacement limits
5. Alpha/performance attribution: see which bots carry the portfolio
Iteration is continuous—never assume parameters are fixed forever.
10. Conclusion & Next Steps
Building a portfolio of Coinrule bots across Hyperliquid’s top tokens gives you:
- Diversified alpha
- Resilience against regime shifts
- Automation at scale using the limits.trade execution layer
- Modular control over risk and capital flows
But success depends on thoughtful design bot templates, risk rules, monitoring, scaling logic, and feedback loops. It’s not “set and forget,” it’s “design, monitor, adapt.”
Start building your strategy with Coinrule now
