Author with AI Companion

Use AI Companion to clarify and review a Signal idea before you implement and validate it.

App path

AI Companion
Signals -> Signal Library
Local Signal Library -> signal.py

What AI Companion does

AI Companion is the no-code way to brainstorm and shape a Signal idea in plain language. It can help turn a trading idea into a clearer Signal specification, challenge assumptions, sketch tests, or produce a code draft for review. It is a collaborator, not an automatic publishing path: it does not add a Signal to the Library, validate a plugin, choose data, or approve a result for you.

Use it before or alongside the Signal SDK when you want to clarify a formula, explore alternatives, identify assumptions, sketch tests, or explain unfamiliar code. You do not need to write Python to use AI Companion for ideation; Python is only needed later if you choose to turn the reviewed idea into a local Signal SDK plugin.

Choose this path	Best for	What it does not do
AI Companion	No-code brainstorming, asking questions, and turning an idea into a reviewable Signal specification	It does not directly create, test, sync, or publish a Signal.
Signal SDK	Writing and testing the local Python plugin that becomes a reusable Signal	It is not a no-code authoring surface.

Start with a bounded request

Open AI Companion and provide the details you want it to use. The companion does not automatically receive the selected Signal, Dataset, or Strategy as full working context, so include only the relevant non-sensitive information in your prompt.

A useful request names the decision you are trying to make and asks for a reviewable output. For example:

CODE

Help me specify a reusable Signal that measures the distance between close and
a rolling session reference. List required inputs, units, parameters and
bounds, warm-up behavior, decision-time availability, output columns, edge
cases, and tests. Do not assume the Signal already exists or make performance
claims.

Avoid pasting credentials, account details, proprietary source files, or data you are not permitted to share with the selected model provider.

Turn the response into a Signal specification

Before writing or accepting code, turn the suggestion into decisions you can verify:

Review area	Questions to answer
Inputs	Which exact fields or upstream Signal outputs are required? Are their units and timing clear?
Formula	Can you describe the calculation in plain language and reproduce it with a small example?
Parameters	Does every setting have a unit, sensible default, supported range, and reason to exist?
Timing	Is every value available at the moment the Signal says it is? Does any rolling calculation accidentally include future rows?
Outputs	Are column names, types, and meanings clear enough for a Strategy author to use correctly?
Data and context	Does it need a particular data shape, session calendar, timezone, tick size, or other instrument fact?
Tests	What should happen during warm-up, with missing data, at session boundaries, and at parameter limits?

Ask the Companion to challenge ambiguous assumptions or generate a small worked example. Do not accept an answer merely because it uses familiar technical language.

Review AI-generated code like any other code

If the Companion produces Python, treat it as an untrusted draft until you have reviewed it. Check that it:

declares every input and output rather than relying on a column name by accident;
uses only information available at the intended decision time;
preserves row alignment and handles warm-up rows intentionally;
has no hidden file access, network calls, provider credentials, or unrelated side effects;
respects the declared parameter types and bounds; and
has deterministic tests you can run locally.

Then implement or adapt the reviewed code through the Signal SDK, run its tests, and sync it into Signal Library. The Library Inspector is the place to verify what the workstation actually received.

Keep the approval boundary clear

AI Companion can explain, question, and draft. The following remain explicit user actions in their owning workflows:

writing or approving the local Signal plugin;
testing and versioning the calculation;
syncing it into Signal Library;
selecting its exact output in a Strategy; and
validating the Strategy against a real Dataset and time window.

An AI answer is not a test result, a data-quality check, or a prediction of live trading behavior. Keep the prompt, reviewed specification, source version, and tests together when you need to explain how a custom Signal was created.

For the final implementation path, continue to Signal SDK.