Write real strategies in real Python.
No no-code blocks, no proprietary scripting. You write Python against a typed strategy SDK in an in-browser editor, declare your parameters, and publish a versioned strategy. An AI assistant works alongside you, grounded in your code and your runs.
The full power of Python, none of the setup.
Pure Python, typed SDK
Strategies subclass a base class with typed events and actions. It's the full language and your own helper files, not a no-code dialect or a charting script.
Parameters up front
Declare parameters in a config schema and set them from the run form. Sweep symbols, sizes, and lookbacks without editing code.
Versioned, not overwritten
Every publish is an immutable version with a checksum. Runs pin the exact version they used, so a result always maps back to the code that produced it.
AI in the editor
Review code, explain failures, and draft changes, all as suggestions you accept, reject, or edit. The assistant proposes; you decide.
An in-browser editor that understands your strategy.
Write and edit your strategy in the browser against the SDK and runtime context. Define parameters with a visual config builder, validate before you publish, and keep helper files alongside your main strategy.
- Python editor with the strategy SDK in context
- Visual config builder for parameters
- Validation before publish
- Multi-file strategies
Assistance grounded in your code and runs.
Ask the assistant to review a strategy, explain why a run failed, or draft a change. It proposes edits as a diff you can accept, reject, or modify, and it can pick up the context of a specific run.
- Author, review, and debug from real context
- Changes arrive as diffs you approve
- Hand a failed run straight to the assistant
- You stay in control of the code
Who this is for.
Traders who want to write code.
If you think in Python and want real control over entries, exits, sizing, and state, without standing up your own editor, runtime, and broker plumbing, this is built for you.
No-code expectations.
There's no drag-and-drop strategy builder. The power is in the code, and so is the responsibility. If you don't want to write Python, Periscøpe isn't the right tool.
Strategy development: questions.
What language are strategies written in? +
Python. You write a strategy class against a typed SDK; events like bars and order updates come in, and you return actions like placing or cancelling orders. You can split logic across helper files.
How do strategy parameters work? +
Parameters are declared in a config schema alongside the strategy. They surface as fields on the run form, so you can change symbols, sizes, and lookbacks per run without touching the code or republishing.
What does publishing a version do? +
Publishing creates an immutable, checksummed version of the strategy. Runs reference a specific version, so every backtest, paper, and live run is tied to the exact code it ran.
What does the AI assistant do? +
It can draft a strategy from a description, review your code, explain a failed run, and review run results, grounded in your strategy and the run context. It returns changes as suggestions you apply yourself; it does not edit code on its own or place trades.
Can I start from an example? +
Yes. You can start from a working example strategy, draft one with AI from plain English, or start from scratch.
Write your first strategy.
We onboard in focused cohorts. Tell us what you trade and how you work. Live access is rolled out to select users on request.