SkillFoxx

Senpi Skills

senpi-skills

Skills and over 80 strategy templates for autonomous trading on Hyperliquid, with exits through a two-phase trailing stop

  • 144 ★ on the repository
  • Last commit
  • MIT
Skill

Broad access

Why this level

  • Strategies open and close leveraged positions by themselves on a real Hyperliquid wallet, and the invested money can be lost.
All reasons and checks

senpi-ai/senpi-skillsAuthor:Senpi

Install

In your terminal, with SkillFoxx CLI

npx skillfoxx add skills/senpi-skills

Detects the agents on your machine, shows the access level and pins the version.

Other ways to install

Access and checks

How we review

Broad accessThe tool can change data, run commands or handle secrets.

  • Strategies open and close leveraged positions by themselves on a real Hyperliquid wallet, and the invested money can be lost.

This is third-party code. Review the repository files before installing.

What it does

Senpi turns an OpenClaw agent into an operator of trading strategies on the Hyperliquid exchange. The skills review a portfolio, read the market, compare the positions of profitable wallets with the crowd, pick a strategy for the user's view and deploy it on a separate funded wallet. Calculations live in scripts: a Python engine returns JSON, and the agent retells the result under strict rules without inventing forward-looking numbers. The `strategies/` folder holds over 80 ready packages: trend, breakout, contrarian, neutral, copy trading and macro. A package consists of a manifest, a `runtime.yaml` file and a scanner that emits signals on a schedule. Position sizing, execution and exits belong to the platform runtime. A two-phase trailing stop first cuts the loss and then moves protection up behind the profit. A strategy is launched and closed with the `deploy.py` and `close.py` scripts of the `senpi-strategy-ops` skill. Data and execution go through Senpi MCP, with access set by a token in the `SENPI_AUTH_TOKEN` variable.

Who it is for. Hyperliquid traders who run autonomous strategies through an OpenClaw agent and want to see the scanner logic in open source.

Good fit when

  • A user states a market view, for example that one coin will outrun the rest, and the agent picks matching templates.
  • After a week the trades are reviewed: profit net of fees, the share of the peak given back, missed signals.
  • Before copying a trader, the trader is checked by a report: repeatability of trades, minimum budget, current positions.
  • A team writes its own `scan(inputs, ctx)` scanner and leaves position sizing and exits to the ready runtime.
  • A morning overview is needed: crypto, equities, commodities, macro and funding rates.

Not a fit when

  • The strategy is expected to return guaranteed profit: templates carry no stated profit, and the project warns that money can be lost.
  • The agent lives on another host: the runtime plugin and the skills are built for OpenClaw.
  • Trading happens on another exchange: all templates and tools are written for Hyperliquid.
  • Automation cannot be trusted with money unattended, because the strategy opens and closes positions by itself.

Example request

I think one coin will grow faster than the market. Pick strategy templates for that view and explain how they differ.

Limitations

The repository holds only the open layer: skills and templates. The Samurai model, the OpenClaw integration, the MCP backend and the `@senpi-ai/runtime` plugin belong to the Senpi platform. Launching needs an OpenClaw host on Linux with Python 3.8 or newer, a Senpi token in `SENPI_AUTH_TOKEN` and a separate funded Hyperliquid wallet for each strategy instance. Trading perpetual futures can lose the invested money, and profit is not promised. The code is distributed under the MIT license.

How to disable. Stop the strategy with the `close.py` script from `senpi-strategy-ops`: it closes positions and returns the funds. Then delete the skill folders from `~/.openclaw/skills/` and remove the runtime plugin with OpenClaw tools.

FAQ

How do I install the Senpi skills?

The shortest path is to deploy an agent on the Senpi site. By hand, run `openclaw plugins install @senpi-ai/runtime` on an OpenClaw host and set up Senpi MCP access. Skill scripts such as `senpi-strategy-ops` run from `~/.openclaw/skills/`.

What is needed to launch a strategy?

An OpenClaw host with the runtime plugin, a token in `SENPI_AUTH_TOKEN` and a funded Hyperliquid wallet for each instance. Then `python3 ~/.openclaw/skills/senpi-strategy-ops/scripts/deploy.py <id> --budget <usd>` creates the wallets and deploys the strategy.

How does a strategy exit positions?

The runtime owns closing. The first phase holds a hard stop at `max_loss_pct`, and the second moves the stop up behind the profit high with a ladder of `tiers`. Templates contain no manual close actions.

How do I close a strategy?

Run `python3 ~/.openclaw/skills/senpi-strategy-ops/scripts/close.py <id>`: the script closes positions and returns the funds. The `openclaw senpi status` command shows the state of a strategy.

Do the skills send orders directly?

No, the repository places no orders directly. A scanner emits signals, while sizing, margin limits and execution pass through the runtime, which halts trading on a daily loss or a drawdown.

Discussion

No questions or reviews yet.

Skills
Official

The Minara skill gives an agent the crypto market in plain language: wallet, token swaps, Hyperliquid perps, limit orders and market analytics

SkillBroad access377

Skills and an MCP server for options traders: quotes, technical analysis, Greeks, spreads, scanners and Interactive Brokers portfolio

MCP serverBroad access410

MCP server for backtesting trading strategies: the agent fetches quotes, runs a test from YAML and reads the metrics on the Backtrader engine

MCP serverExtended access1.1K

A set of skills for individual investors and traders: market review, stock screening, technical analysis, trade planning, journaling and post-trade review

SkillBroad access3.8K

A skill that finds bottlenecks in an industry's supply chain and shortlists A-share, Hong Kong and US stocks with data checks

SkillExtended access532

Four skills for China's A-share market: quotes and indicators, trend-pullback signals, a simulated account and backtests

SkillExtended access261

README in short

The document describes the Senpi harness: the model, the OpenClaw host, skills, 62 MCP tools, the supervising runtime and the exchange. Tables of skills and strategy archetypes follow, then the scanner contract and the safeguards: a daily stop, a cap on entries, pauses after a losing streak.

README badge

Original SKILL.md

---
name: senpi-strategy-discover
description: >-
  Help a user choose a Senpi trading strategy to deploy — a conversational,
  analyst-style picker. Use when the user asks "what should I trade?", "recommend
  a strategy", "help me pick a strategy", "what's winning?", "set me up", "I have
  a view on the world (a war, the economy, one coin winning) — trade it", "run a
  hedge fund / all-weather / tail-risk book", or wants a strategy but has NOT
  named a specific one — and every discretionary mandate: "deploy whatever you think is
  profitable", "trade for me", "be aggressive", "put it to work", "you decide". A mandate is a
  strategy request even when it names no strategy and no coin; it is never answered with
  hand-picked raw positions. Surface the closest matching TEMPLATE first — the quick start
  to the user's OWN strategy (every template deploys as `<User>'s <Template>` — or a
  name of their own — as-is or with levers moved, after ops walks them through it) — passing their
  worldview as `--theme` to rank the closest fits; offer building one as a peer with
  its cost class, never a downsell. You talk and RANK; a hidden engine
  (scripts/discover.py) fetches data + filters. NOT for installing a NAMED
  strategy (that's senpi-strategy-ops), or building/designing one from scratch or
  with a custom DSL (that's senpi-strategy-author).
license: Apache-2.0
metadata:
  author: Senpi
  version: "2.52.0"
  platform: senpi
  exchange: hyperliquid
---

# Senpi Strategy Discover — the analyst-style picker

You are a sharp trading analyst helping the user pick a strategy. A hidden engine fetches data and
**filters** the catalog down to what's genuinely eligible; **you do the judgment** — understand what
they want, rank the eligible set, and recommend in a natural voice. It must never feel like a form.

## The split: the engine FILTERS, you RANK

- **The engine only removes the impossible.** `scripts/discover.py` takes a few **concrete** filter
  flags, computes the complete eligible set, folds each variant family into one card, and returns a
  bounded shortlist (8 by default): `meta.eligible_count` is how many fit, `meta.families_count` how
  many cards they fold into, `meta.returned_n` how many came back.
- **Only `--theme` makes that shortlist a ranking.** With `--theme`, the engine scores the whole eligible
  set on the user's words, then cuts — the 8 are the best matches. Without it, the 8 are the first 8 in
  **neutral order** (asset match, then name — effectively alphabetical), not the best 8.
- **Soft preferences go in `--theme`, never in a filter.** Risk appetite, belief, horizon and worldview
  never become `--assets`/`--direction`/`--exclude`/`--budget` cuts — `--theme` ranks and never drops.
  Then you rank the returned candidates yourself, using the fields on each record (`risk_level`,

Report a problem