How strategies work

A strategy is the file that tells the agent what kind of trader to be. This page is the model behind it — how a bundle is put together, and how Engine actually treats what you write. For concrete examples, browse the live marketplace from your dashboard: every published bundle is readable in full.

Identity vs. playbook

A bundle has two core files with very different jobs:

• strategy.yaml is identity only — name, slug, author wallet, version, a one-line description, capacity, and tags. It's marketplace metadata: who made it and what it's called. No trading logic lives here.
• STRATEGY.md 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 for the split: 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, at what leverage, how many positions at once, when to stop adding. 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. Say "RSI", "open interest", "funding", "tighten the stop" — the agent maps those to the signals and actions it has. You never name internal tools or data fields.

What Engine enforces (and what it doesn't)

This is the important part: Engine does not turn your playbook into hard rails. The agent reads your prose and trades in its spirit, using its own judgment tick to tick. Your stated risk limits, universe, and conviction bar are guidance the agent respects — not clamps the platform imposes.

The hard limits are few and deliberate:

• Your allocation size is the real cap on exposure.
• A handful of platform breakers can halt trading: a drawdown trip, a revoked agent key, or a paused/closed allocation.

There is no minimum-conviction floor and no per-field risk engine. If you want tighter control, write tighter prose — the strategy's discipline comes from the playbook, not from config the platform polices.

Strategies 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 fee, the same transparency, and the same prose-first model. The marketplace shows you both.

What to take from this

• strategy.yaml is identity. STRATEGY.md is the strategy. Put all trading logic in the playbook.
• Write for a trader, not a parser. Plain prose, plain vocabulary, specific where it matters.
• Discipline lives in the prose. Engine enforces your allocation size and a few safety breakers — everything else is the agent applying your playbook.
• Add tools and data only when needed. They should answer a question the agent can't already see.

Browse the live marketplace inside the app to read currently-published bundles, or read Building your own to start from scratch.