How agents work

Every agent is defined by a strategy: the file that tells it what kind of trader to be. This page explains how a bundle is put together and how Engine treats what you write.

Identity and playbook, one file

A strategy is a single file, STRATEGY.md, with two parts — the same shape as a Claude Skill:

• The frontmatter is identity — a short --- ... --- block at the top holding a name, a one-line description, and type: spot or type: perps (optionally tags). Engine sets the author from your account and derives the slug from the name.
• The body is the whole strategy — the playbook the agent reads as its constitution. Your universe, your edge, your setups, your sizing, your exits, and your abstain conditions all live here, in plain prose.

There's a reason identity is just two lines: the agent is a capable generalist trader, and your playbook is the brief that makes it trade like you. Everything about how to trade is prose the agent reads and applies — not config it's mechanically constrained by.

What a good playbook covers

STRATEGY.md has no required structure — write at whatever precision the setup calls for — but strong ones tend to cover, in some form:

• Edge. What you're capturing and why it persists.
• Universe. Which markets, and why they fit. Name them, or describe them ("liquid majors", "mega-cap tech", "gold and silver") — the agent maps your words to the right market. (See Supported markets for the full list.)
• Setups. The conditions to engage, in language the agent can apply judgment to. Lead with conditions, not opinions.
• Sizing and risk. How big, how many positions at once, when to stop adding, and leverage when the strategy uses it. State it plainly; the agent respects it.
• Exits and management. When to take profit, cut, or trail — and what invalidates the thesis.
• Abstains. When not to trade: vol spikes, thin books, pre-event uncertainty, regime mismatch. The skips matter as much as the entries.
• Horizon. How long you expect to hold; the agent also infers it from your entry and exit language.

Write in a trader's vocabulary, not the platform's. The agent maps your language to the signals and actions available for its type.

What Engine enforces (and what it doesn't)

The strategy prose governs the universe, entries, sizing, position management, exits, and abstain conditions. Engine does not require a strategy-level exposure ceiling. If you want one, state it clearly in the playbook.

Before publishing, Engine checks that the strategy's important indicators and timeframes exist in the built-in data catalog or a declared custom feed. A core condition that cannot be supplied is a clear publish error. Engine does not silently replace a one-hour signal with a four-hour signal or drop half of a setup.

Execution checks can still reject an unavailable or unsafe trade, but they do not replace the trading rules in your strategy. During a live review, missing evidence cannot prove an entry or discretionary exit. The agent waits or keeps the position's existing protection unless the strategy states a real fallback.

How a strategy becomes trades

The agent first reviews markets once for everyone running it and publishes durable trade ideas, either one at a time or as a coordinated book. It does not use one user's balance or positions to decide what the strategy believes.

Engine then applies each idea to every user separately. This step is mechanical: it checks the account's current funds, positions, the strategy's sizing and book rules, venue requirements, and the user's approval setting. It does not ask another AI model to reinterpret the entry.

After a trade fills, position management is private to that account. The position stays linked to the exact strategy version and idea that opened it. A reduction, close, or protection change must be supported by the strategy's own condition and current evidence; an unrelated idea for the same market cannot control it.

Agents scale with ambition

A bundle can be one file or up to 64. Some are a single playbook refined over months; others are full research pipelines:

• Custom data sources (endpoints.yaml) — HTTPS feeds Engine polls on a schedule (TTL down to one second). Returned numeric identifiers merge into the agent's snapshot for every market in your universe.
• Tools (tools.yaml) — HTTPS endpoints the agent calls on demand, by name, when your prose says it needs them. Bearer auth, JSON-Schema in and out. Use them for context the agent only needs sometimes: news, a liquidity report, a proprietary model.
• References (references/) — long-form notes the agent pulls in only when a setup needs more depth than the main playbook carries, so the everyday prompt stays lean.

The simplest and most sophisticated bundles share the same prose-first model.

What to take from this

• Identity and type live in the frontmatter; everything below it is the strategy. Put all trading logic in the playbook prose.
• Write for a trader, not a parser. Plain prose, plain vocabulary, specific where it matters.
• Discipline lives in the prose. The strategy defines the rules the agent applies.
• Add tools and data only when needed. They should answer a question the agent can't already see.

Browse the Agents page to read available agents, or read Building your own to start from scratch.