I started Managing before ChatGPT existed. For a long time it was just a trading product: write a strategy, simulate it, run it. No assistant, no chat window. When I finally added AI, I already knew the job I wanted it to do. Help me say a hypothesis out loud and poke at it. Do not sit in the chair and press buy.
Separate assistance from authority
How deep do you want the LLM in the decision chain?
Not “can it trade?” but how far in before real money moves? That question hit me early on Managing, harder than picking a model.
I use Semantic Kernel as the orchestration layer. It proposes plans and typed tool calls; it does not own outcomes. An assistant can turn natural language into a candidate scenario, explain an indicator, or suggest exploration ranges. Every result lands as a deterministic configuration you can open, edit, backtest, and approve.
The model drafts. Semantic Kernel routes through MCP and platform APIs. You decide how far that chain runs: draft only, backtest, paper, or live. I drew a hard line at execution: no chat path that can emit live orders. Let the LLM creep one step too deep and every prompt injection becomes a financial incident.
On Managing, the model helps draft a strategy config. Deterministic backtests, OOS gates, and an explicit deploy step own authority, never a free-form chat reply.
Make simulation reproducible
If the AI helped draft it, can I run it again tomorrow and get the same answer?
Pretty equity curves were not enough. I needed to trust that what the model produced could be replayed, not re-imagined.
That works because the trading core is deterministic. The LLM never runs inside the simulation loop. It outputs a typed bot configuration with indicators, parameters, fees, and date range, and the same engine evaluates it in backtest, paper, and live. Same inputs, same rules, same outcome path.
Stochastic models sit above the core; deterministic execution sits below. Swap the assistant, change the provider, rerun the config: you still get an answer you can compare. Intelligence without that boundary is persuasive noise.
The LLM drafts configuration. The trading core runs the same deterministic engine in backtest, paper, and live, so AI output stays replayable.
Design for refusal
What should the product do when the answer is no, or when it is yes?
Invalid configs, incomplete candles, risk-limit conflicts, and model uncertainty are not edge cases. They are gates the system must surface before anyone promotes a strategy.
Managing compresses backtest quality into an aggregated Score from 0 to 100, built from weighted checks like growth, Sharpe, drawdown, HODL comparison, win rate, and fees, with hard early exits when basics fail: no trades, negative PnL, or clear underperformance. The ScoreMessage lists what passed and what did not; when every check is green, the operator gets one comparable number to rank AI-drafted configs instead of guessing from a pretty chart.
A system that only knows how to say yes will eventually say yes at the wrong time. Refusal is explicit; approval should be just as inspectable.
How this stays future-proof
Models will change. Providers will churn. The durable piece is the contract: assist → inspectable config → reproducible simulation → gated promotion → explicit deploy.
Semantic Kernel, MCP, and the CLI sit on top of the same APIs the web app uses. Swap the LLM tomorrow and the research and execution spine still hold. That is how I keep Managing adaptable without rewriting the trading core every quarter.
Future-proofing is also about who owns the model choice and the bill. Managing supports BYOK: plug in your own OpenRouter API key, pick the model you want from their catalog, and Semantic Kernel routes through it with the same tool contracts and deterministic trading core. Once configured, your key replaces the platform default, so you can change models without rewriting the product.
Conclusion
How do you build when the stack shifts every week?
Managing started without AI, before ChatGPT and the current wave of assistants. I added AI later, once the deterministic trading core and product boundaries were already in place. The AI layer will keep moving: new providers, new agents, new hype cycles.
Staying open-minded, for me, means adding AI around stable foundations rather than rebuilding everything around each new model. Thin adapters, explicit contracts, and a deterministic core outlive fashion. Be curious about what launches on Tuesday; do not let it rewrite your trading brain on Wednesday. That is what keeps Managing adaptable.