What are strategies?

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. Think of it as a trading skill — modeled on Anthropic's Claude Skills: a single markdown file with a short identity block at the top, then instructions in plain English. Engine's agent is a capable generalist trader, and your file is the specialist brief that makes it trade like you.

my-strategy/
|-- STRATEGY.md
|   # The whole strategy, in one file — modeled on a Claude
|   # Skill. Identity frontmatter at the top (just name and a
|   # one-line description), then the playbook in plain English:
|   # mandate, universe, entry setups, sizing, management,
|   # exits, time horizon, and when to abstain.
|
|-- 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.

One file, not a config form

A strategy is a single markdown file — STRATEGY.md — with two parts.

• The frontmatter is the --- ... --- block at the very top: a name and a one-line description (plus an optional version and tags). That's the whole identity surface — the same minimal shape as a SKILL.md. Engine stamps the author from your account and derives everything else, so there's no wallet to paste or slug to invent. This is what the marketplace card shows.
• The playbook is everything below the frontmatter. 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.

Three optional files sit alongside it, for strategies that need more:

• endpoints.yaml declares custom HTTPS data feeds Engine polls and merges into the agent's snapshot.
• tools.yaml declares HTTP tools the agent can call by name when a setup is close enough to justify the latency.
• references/ hold longer-form markdown files the agent lazy-loads when a setup needs more depth than the playbook covers.

The playbook is what makes the agent yours. The frontmatter is just a label so the marketplace can surface it, and the optional files 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.