S.A.M.S. — Smart Autonomous Market System

Overview

S.A.M.S. (Smart Autonomous Market System) is an AI-powered autonomous trading system for cryptocurrency markets, built around a multi-agent architecture rather than a single monolithic strategy engine. Instead of one model making every decision, S.A.M.S. splits market analysis, risk management, and execution across cooperating agents.

Problem

Most retail trading automation is built as a single hard-coded strategy: one set of indicators, one risk model, no memory of past decisions, and no way to reason about why a trade worked or failed. That makes it brittle across changing market regimes and impossible to audit after the fact.

Solution

S.A.M.S. treats trading as a system-design problem, not a script. Specialized agents handle distinct responsibilities — market analysis, risk assessment, execution — and share state through a persistent knowledge layer instead of ephemeral in-memory variables, so the system can reason about market structure and its own past decisions rather than reacting to price alone.

Architecture

• Python
• FastAPI
• React
• TypeScript
• PostgreSQL
• Neo4j
• ChromaDB
• Redis
• Docker
• Ollama
• Qwen2.5
• Bybit API

• FastAPI backend exposes the agent orchestration layer and trading API to a React + TypeScript dashboard.
• Neo4j stores market entities and relationships as a knowledge graph (assets, signals, positions, causal links between events).
• ChromaDB provides vector-embedding memory so agents can retrieve semantically similar historical situations rather than only exact matches.
• Redis handles fast shared state and pub/sub between agents.
• Ollama running Qwen2.5 gives the reasoning agents local LLM inference — analysis and decision rationale don't depend on an external API.
• PostgreSQL is the system of record for trades, positions and account state.
• Bybit API is the execution venue for live and paper trading.
• The whole stack is containerized with Docker for reproducible deployment.

Features

• Multi-agent decision pipeline (analysis → risk → execution) instead of a single strategy function.
• Persistent knowledge graph of market structure, not just a rolling price buffer.
• Vector-based memory retrieval for pattern/context recall across past market conditions.
• Local LLM inference for reasoning steps, independent of third-party API uptime or cost.
• Direct integration with Bybit for live crypto execution.

Technologies

• Python
• FastAPI
• React
• TypeScript
• PostgreSQL
• Neo4j
• ChromaDB
• Redis
• Docker
• Ollama
• Qwen2.5
• Bybit API

Gallery

Screenshots and system diagrams are being prepared and will be added here via the dashboard.

Videos

No walkthrough video published yet.

Roadmap

1. Multi-agent core (analysis, risk, execution)

2. Knowledge graph + vector memory integration

3. Live Bybit execution

4. Public performance reporting

Challenges

Coordinating multiple agents without them contradicting each other required an explicit shared-state layer (Neo4j + Redis) rather than letting each agent hold its own private state — a common failure mode in naive multi-agent designs.

Lessons

Separating memory (what happened) from reasoning (what it means) into distinct storage systems — a graph for structure, a vector store for similarity — made the agents far easier to debug than a single opaque model would have been.

Future

Expanding the risk-management agent's coverage across more market conditions and building a public, verifiable track record of the system's live performance.

GitHub

This is a private project — there is no public repository at this time.

Demo

No public demo is available; S.A.M.S. trades live on private accounts.

FAQ