What are agents?

An agent on Engine is an AI trader you run. What defines it is its strategy: a plain-English file that tells it 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.

Each agent is either Spot or Perps. Beyond that required type, there is no fixed menu of indicators or configuration form. You describe what a real trader would describe, and the agent applies it. Think of the strategy as a trading skill: a markdown file with a short identity block at the top, then instructions in plain English.

my-strategy/
|-- STRATEGY.md
| # The whole strategy, in one file — modeled on a Claude
| # Skill. Identity frontmatter at the top (name, description,
| # and type: spot or perps), 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, a one-line description, and type: spot or type: perps (plus optional tags). Engine stamps the author from your account and derives everything else.
• 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 agents 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 type tells Engine which markets and execution path the agent uses, 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 trading frameworks make you pick from a fixed menu: RSI, MACD, an EMA cross, a funding threshold. The menu becomes the ceiling of what your agent can do.

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

Buy Spot tokens when volume, participation, and price structure confirm each other.

Fade extreme funding on top-volume perps.

Skip a Spot entry while sell pressure is still accelerating.

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 sees the market data relevant to its type. For private or specialized signals not in that snapshot, you can plug in your own data (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 agent is one file: a playbook that says what to trade and when. That's enough to run.

The most sophisticated agents 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.
• 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 run an agent that already exists, browse the Agents page.
• If you want to build your own, Building your own walks through it.
• If you want to see how the pieces fit together, read How agents work.