What are strategies?

A strategy is a plain-English file that tells the agent what kind of trader to be.

A strategy on Engine is a plain-English file that tells the agent what kind of trader to be: what markets it can touch, how much risk to take, what setups to look for, and when to sit on its hands.

There's no rigid template, no fixed menu of indicators, no mode to pick. You describe what a real trader would describe, and the agent applies it.

strategy bundle
my-strategy/
|-- STRATEGY.md
|   # The playbook, in plain English. Mandate, universe,
|   # entry setups, sizing, position management, exits,
|   # time horizon, and when to abstain.
|
|-- strategy.yaml
|   # Identity + marketplace metadata only.
|   # name, slug, author, version, description, tags.
|
|-- endpoints.yaml
|   # Optional. Custom data feeds Engine polls each tick
|   # and merges into the agent's snapshot.
|
|-- tools.yaml
|   # Optional. HTTP tools the agent calls by name.
|
`-- references/
    # Optional markdown the agent lazy-loads when a
    # setup needs more depth than the playbook covers.

A bundle of files, not a config form

Every strategy is a small bundle. Two files are required, the rest are optional.

  • STRATEGY.md is the playbook. Plain English. The agent reads it the way a junior trader reads a senior trader's notes: thesis, setups you want, what kills them, how to size, how to exit. Write whatever you want here. The agent reads the whole thing and applies all of it.
  • strategy.yaml is identity and marketplace metadata: name, slug, author wallet, version, a one-line description, capacity, and tags. No trading logic lives here — your universe, risk, and exits all go in the playbook.
  • endpoints.yaml (optional) declares custom HTTPS data feeds Engine polls and merges into the agent's snapshot.
  • tools.yaml (optional) declares HTTP tools the agent can call by name when a setup is close enough to justify the latency.
  • DESCRIPTION.md (optional) is the marketplace pitch readers see before they ever look at the playbook.
  • references/ (optional) hold longer-form markdown files the agent can lazy-load when a setup needs more depth than the playbook covers.

The playbook is what makes the agent yours. Everything else is scaffolding: identity so the marketplace can surface your strategy, and optional files that feed the agent extra context at the right time.

Bring your own signals

This is the part that makes Engine different.

Most strategy frameworks make you pick from a fixed menu: RSI, MACD, an EMA cross, a funding threshold. The menu becomes the ceiling of what your strategy can do.

Engine is built differently. Anything you can describe clearly, the agent can reason about. Your strategy can say things like:

Fade extreme funding on top-volume perps.

Reduce position size in the 24 hours before a Fed meeting.

Skip when ETH spot is bleeding into stablecoins faster than $50M an hour.

Sit out the first hour after a major exchange listing.

Take long bias when SOL OI is building three days into a quiet week.

The agent already sees a rich snapshot of every market in your universe: price, funding, basis, open interest, depth, realized volatility, regime tags, and more. For private or specialized signals not in that snapshot, you plug your own in (covered in Building your own).

How specific you get is up to you

If you write "trade when funding is extreme," the agent makes a judgment about what extreme means in the current market, grounded in everything else you wrote. Often that's exactly what you want.

If you want a precise threshold, write it directly:

Enter long when 1-hour funding drops below -100bps, RSI(14) is below 30, and realized volatility is under 80%.

Either reads to the agent the same way: as text it considers alongside everything else in your playbook and the live market. There's no separate language to learn, no special block to fill in, no compilation step. Write the way you'd write notes to another trader, at whatever level of precision matters for the setup.

How sophisticated you go is up to you

The simplest strategy is one file: a playbook that says what to trade and when. That's enough to run.

The most sophisticated strategies on Engine are full research pipelines. They can:

  • Stream private signals into the agent's view. An endpoints.yaml file declares HTTPS feeds that Engine polls on a schedule. Whatever numeric values you return (a proprietary regime score, a custom sentiment index, a private on-chain flow metric) are merged into the agent's snapshot of every market. The agent reads them alongside funding and depth as if they were native.
  • Give the agent its own tools. A tools.yaml declares HTTPS endpoints the agent can call by name when a setup is close enough to justify the latency. Your own news fetcher, a custom analyst model, a deep liquidity reader, a private backtest service. The agent decides when to call them.
  • Carry deep reference material. A references/ folder holds long-form markdown the agent loads only when a setup needs it: regime playbooks, market-specific tactics, sizing matrices, post-mortems.

A bundle can be a single file or up to 64 of them, totaling up to 1MB. Engine doesn't care which end of the spectrum you live on. The agent reads what you give it and trades inside the constraints you set.

What's next

  • If you want to use a strategy that already exists, head to The marketplace.
  • If you want to write your own, Building your own walks through it.
  • If you want to see what a finished bundle looks like, browse The marketplace — or read How strategies work for the model behind one.