Building strategies

A strategy in BrokerBridge is a deterministic definition that carries its indicator choices and its entry/exit logic together. BrokerBridge supplies generic building blocks and can load user-owned indicators from your profile; proprietary strategy logic stays outside the shipped Retail app.

The core idea

Most people don’t think “build an indicator, then build a separate strategy that references it.” They think: “use a 20-period moving average; when price closes above it, enter; when it closes below, exit.”The indicator and the logic are one thought. BrokerBridge keeps them as one thing.

A strategy = its indicators + its entry/exit logic. The user experience is one strategy, not a separate indicator-registration workflow. Current saved/API payloads still use the legacy primitive field for compatibility, while newer docs and UI use strategy/indicator vocabulary.

What a strategy contains

Everything the strategy needs to decide is declared by the strategy and resolved from the vetted runtime:

•Indicators — generic built-ins plus profile-loaded user indicators that stay local to your machine.
•Entry and exit logic — the rules that turn those indicators into decisions: when to get in, and when to get out.
•Parameters & universe — the periods, thresholds, and symbols it operates on.

If a strategy needs proprietary math or a trained model, keep it in your local strategy or user-indicator profile. BrokerBridge ships generic components and loading hooks, not your private edge.

Two ways it can run — your choice

Once a strategy exists, you decide how much autonomy it has. The same strategy can run through supervised proposal gates, or through stronger autonomous/oversight modes as those modes are explicitly enabled and verified. This is the hybrid at the heart of BrokerBridge.

Static — deterministic (default)

The strategy runs exactly as configured. Its own entry/exit logic decides signals; BrokerBridge routes those decisions through the configured proposal, risk, and execution controls. Nothing adaptive rewrites it.

Adaptive — AI-overseen (opt-in)

On top of the strategy, BrokerBridge can apply configured approval, risk, and oversight layers. Advanced AI risk-management behavior is being built as an explicit opt-in mode; it is not assumed for current static strategies.

So a strategy is deterministic on its own, and any adaptive/protective layer must be explicitly enabled and verified for the account mode you are using.

What BrokerBridge provides — and what it doesn’t

BrokerBridge does

Feed your strategy market data each cycle.
Run the strategy through the configured proposal, risk, and broker-execution path.
Provide generic indicators/components and profile-loaded user indicators.
Optionally apply configured approval, risk, and oversight protections.

BrokerBridge does not

Provide packages your strategy depends on.
Make you register indicators separately first.
Interfere with a static strategy you’ve chosen to leave deterministic.
Ship your proprietary logic or models inside the Retail app.

Building a strategy

You describe the strategy the way you’d say it out loud. The indicators and the logic are authored together as one strategy definition — there is no separate indicator-creation step in the product flow.

  "Use a 20-period moving average.
   When price closes above it, go long.
   When price closes below it, exit."

   ->  one strategy definition:
       - the 20-period MA is declared as the indicator
       - the entry and exit rules live with it
       - BrokerBridge runs it through configured risk/execution controls
       - optional oversight layers can sit on top when enabled

The same holds for anything more advanced — a custom volatility indicator, a regime filter, a trained model. It is declared in the strategy or loaded from your local profile, depending on whether it is generic or proprietary.

For AI agents building on behalf of a user

If you’re building a strategy for someone, you mostly already know how — these are the guardrails that keep it compatible with BrokerBridge:

•Complete — the strategy definition names every indicator, rule, parameter, and execution component it needs.
•Built the way the user thinks about it — the indicator and the rule together, not a separate “make an indicator first” step.
•Complete and deterministic on its own — it should run correctly with nothing watching it, deciding on completed data; the adaptive layer is an addition, not a crutch.
•Let the user choose the autonomy — deliver the strategy, and let them decide whether to leave it static or switch on the adaptive/protective layer. Try it on a paper account before anything real.

The mental model: the strategy is the brain; BrokerBridge is the hands — and, when invited, a second set of eyes.

Your logic stays yours

Your proprietary indicators and models never become part of the shipped BrokerBridge app. They live in your local profile or private strategy source, and the public Retail app only carries the generic runtime and loading hooks.

← Trading Flow Data & Reports →