This document defines the long-term product intent so implementation details can evolve without losing core direction.
Build a modular, AI-native trading copilot that helps a human trader make better decisions, learn over time, and stay in control.
ClawQuant should feel like one consistent intelligence that:
- Understands natural language requests.
- Uses tools and plugins to take real actions.
- Remembers context and improves from outcomes.
- Stays modular so capabilities can be added without rewriting the core.
- ClawQuant advises.
- The human owns execution authority by default.
- Safety and risk constraints stay deterministic where required.
- Maintain two separate portfolios:
- AI portfolio (what the system would do).
- Human portfolio (what the user actually did).
- Compare them over time to measure divergence and decision quality.
- Use divergences as explicit learning inputs, not hidden heuristics.
- Generate structured memories from AI-vs-human divergences.
- Persist and retrieve those memories as first-class context.
- Use learning loop outputs to improve future analysis behavior.
- The same central AI should power:
- direct chat conversations
- scheduled
ai.run_prompttasks
- Behavior, tools, and system rules should remain consistent across triggers.
- Core defines protocols and contracts.
- Plugins implement integrations, providers, and tools.
- Event bus remains the primary coordination mechanism.
- Simulation and historical reasoning must enforce time visibility (
TimeContext,available_at) to avoid lookahead bias. - Backtesting and live behavior should converge toward parity as the simulator matures.
When a user talks to ClawQuant, they should be able to:
- Ask naturally (any language, normal phrasing).
- Have the system act immediately when tools allow it.
- Schedule recurring intelligence jobs with the same AI they already use.
- Understand what changed, why it changed, and what was learned.
The implementation roadmap should continue converging toward:
- Fully wired orchestrator -> risk -> delivery runtime path.
- Stronger automated learning-loop orchestration (without losing transparency).
- Simulator integration as a first-class workflow.
- More plugin breadth without breaking the modular core.