Jesse: a crypto trading framework for people who already write Python

A strategy is a class, and the README shows the whole thing

The clearest way to understand Jesse is the eleven-line strategy class in the README, because it contains the whole model of how the framework thinks:

class GoldenCross(Strategy):
    def should_long(self):
        # go long when the EMA 8 is above the EMA 21
        short_ema = ta.ema(self.candles, 8)
        long_ema = ta.ema(self.candles, 21)
        return short_ema > long_ema

The shape is worth reading closely. `should_long` is a pure question, returning a boolean. `go_long` is where orders get placed, and it sets three attributes: `self.buy` for the entry, `self.take_profit` and `self.stop_loss` for the exit. Order quantities come from a helper, `utils.size_to_qty`, called here with 5 percent of the account balance so the example risks a small fraction per trade rather than everything.

Two design choices stand out. First, entry, profit target and stop loss are declared together in one method, so a reader sees the complete risk profile of a position without chasing state across the class. Second, the prices are computed relative to `self.price`, the current price, rather than hardcoded levels, which is what lets the same strategy run across symbols and timeframes. The README claims over 300 indicators are available, with multi-symbol and multi-timeframe support and no look-ahead bias, and mentions Rust-native implementations for indicator-heavy work and large research runs.

One strategy file across backtest, paper and live

The feature list is organised around the research lifecycle rather than around components. Backtest, paper trade and live trade run the same strategy code, and the README says explicitly that the same interactive charting workflow applies to backtests and to running or completed paper and live sessions. That claim is the framework's main argument, because the usual failure mode of a trading bot is a strategy that backtested well and then behaved differently once real order types and partial fills were involved.

Supporting that, the README lists market, limit and stop orders, partial fills for entering and exiting in multiple orders, leveraged and short positions, spot and futures, DEX support, multiple accounts, and alerts to Telegram, Slack and Discord. A built-in code editor and a metrics system sit alongside, and a debug mode is described as letting you observe the strategy in action with detailed logs.

The interactive charts deserve a separate mention because they address the hardest part of debugging a strategy: seeing where the decisions were made. The README describes synchronized candlestick, indicator and level panes with executed orders and completed trades, the ability to expand a trade to inspect every execution, follow OHLC and indicator values under the cursor, and export the chart as an image. The same view is available for a backtest, which is what makes a suspicious result traceable to the candle that caused it.

Statistics aimed at the pretty-curve problem

Most backtest output is a performance chart, and a performance chart can be produced by a strategy that has no edge. Jesse includes three tools that exist specifically to attack that, and they are the most differentiated part of the feature list.

Rule significance testing answers whether an entry rule shows genuine historical edge or could have appeared by chance. Monte Carlo analysis goes further: it stress-tests a strategy by shuffling trade order and running candle-based simulations, so you can see the distribution of outcomes your strategy produces when the sequence of trades is rearranged. A strategy whose profit depends on one lucky trade ordering collapses under shuffling, which is a cheaper way to find out than finding out live.

Beyond that there is a benchmark feature for batch backtests, comparing across timeframes, symbols and strategies with results filtered and sorted by performance metrics, and an optimize mode using Optuna with parallel processing powered by Ray. The research API and Jupyter support extend the same set of operations, including significance tests, Monte Carlo analysis and candle workflows, into notebooks and scripts, so a research session does not have to run through the GUI.

A built-in machine learning pipeline rounds it out: gather labelled training data from backtests, train scikit-learn models for binary, multiclass or regression targets, then use predictions inside a strategy. That is a natural fit here because backtests are already a labelled data source, and it is also the fastest route to overfitting if the labels leak the future.

Packaging details and the metadata that disagrees with the README

Setup is conventional: `setup.py` defines version 3.2.0, declares a `jesse` console script pointing at `jesse.__init__:cli`, requires Python 3.10 or newer and reads its install requirements directly out of `requirements.txt`. That file pins arrow, blinker, click, numpy 1.26.4, pandas 2.2.3, peewee, psycopg2-binary, pydash, fnc, pytest, requests. Peewee as an ORM plus psycopg2 is the notable pairing: it points to a relational store for trade records, most likely PostgreSQL, rather than a document store.

Two pieces of what GitHub reports sit awkwardly with the README, and both are worth knowing before you decide how much to trust the project's self-description. GitHub's description calls Jesse an advanced crypto trading bot written in Python, while the README consistently describes it as a framework for researching and defining your own strategies. Those are different products: a bot is something you install and it trades, a framework is something you write code against. The README's framing is the one supported by the code in the repository.

The second is the language. GitHub reports Python as the primary language, and the README advertises Rust-powered indicators as native implementations that make indicator-heavy strategies and large research runs faster. Both can be true, since a Rust extension compiled into a Python package is still a Python project on GitHub, and setup.py's `package_data` listing of `*.dll`, `*.dylib` and `*.so` confirms compiled binaries ship with the package. But it does mean installation is not pure Python everywhere, and that the performance claim depends on those native modules loading on your platform.

The repository has no GitHub releases despite carrying a 3.2.0 version string in setup.py, so there is no changelog to read and nothing to pin a deployment to except a commit. The default branch is `master`, and the tree includes a Dockerfile, a `codecov.yml`, an `AGENTS.md`, a `.agents/` directory, `conftest.py` at the root, a `tests/` directory and a `docs-perf/` directory.

Self-hosted, with an MCP bridge and a roadmap item

The privacy position is architectural rather than a policy promise. The README describes Jesse as fully self-hosted so that strategies and data remain on your own machine, and lists it among the key features alongside support for spot, futures and DEX markets. For a trading bot this matters more than for most software, because strategy source is the asset.

The feature list has moved well past the original backtesting niche, and one entry is worth calling out because it shows where the maintainer thinks the framework is going. Alongside the Jesse MCP bridge, which connects Claude, Codex, Cursor, VS Code and Zed to a local Jesse project, the README lists reinforcement learning as coming soon, described as first-class workflows built on the existing simulation and research stack.

A coming-soon marker deserves a specific reading. The simulation engine it would sit on is the same one that runs backtests, which is what makes the idea coherent, and the research API already exposes those operations to Python scripts. What is not present in the repository is any reinforcement learning implementation, so treat it as a direction of travel rather than something you can read today. The tree does include an AGENTS.md file and a .agents/ directory, consistent with the repository being set up for AI-assisted development, which matches the MCP entry appearing elsewhere in the same list.

The MCP bridge is the more immediate one. Exposing your local trading project's data to an AI assistant is convenient for exploring backtest results, and it is a decision about trust boundaries you should make deliberately rather than by default.

How Jesse compares to the alternatives

The real comparison is with three other things a Python trader might use. A hosted bot service handles execution for you and gives up control of the strategy source. A general research library such as a backtesting framework or a data stack gives you more flexibility and more work, because you assemble the execution layer yourself. A charting platform with a scripting layer is easy to start and awkward to grow.

Jesse sits with the second group on ambition and with the first on ergonomics. It covers the path from idea to live order in one framework, which most research-oriented libraries deliberately do not, and it keeps the whole thing on your own hardware. What you give up for that integration is neutrality: the strategy API, the indicator set and the order model are Jesse's, so leaving means rewriting rather than reconfiguring.

The clearest signal of where it has invested is the statistics and charting layer rather than the execution layer. Anyone can submit a market order; showing whether a rule has edge and letting you inspect the candle where a decision was made is more work, and it is what separates a research tool from a signal generator.

One caveat to carry forward: the README makes accuracy and simplicity claims without publishing benchmarks, so the no-look-ahead-bias claim and the Rust indicator speedups have to be taken on description rather than measurement. The verification path is available, since the rule significance and Monte Carlo tools exist precisely so you can run the check on your own strategy rather than trusting the project's summary of it.

Editorial conclusion

Jesse is aimed at a specific person: someone who can already write Python and wants a backtest and a live run to share one strategy file, rather than translating between a research notebook and an execution engine. The `Strategy` class makes that possible, the indicator library is broad, and the statistics tooling, rule significance testing and Monte Carlo shuffling, attacks the specific failure of a pretty backtest curve. Read the Golden Cross example in full before writing your own, and treat the strategy that ships with the README as a shape to fill in rather than a starting point. The last push was on 2026-09-17 and the package version in setup.py is 3.2.0.

Frequently asked questions

Official sources

1. Issues
2. jesse-ai/jesse on GitHub
3. License: MIT
4. Project website
5. README