ClawlasDocs
Open the app
Operations

Implementation phases

The eleven build phases from foundation to controlled production — a single, sequenced source of truth, with live build progress.

The build progresses through eleven phases, centered on the early-token pipeline. This page is the single source of truth for the sequence — the landing timeline reads the same data. Trading only begins once detection, security, features and agents exist, and even then through shadow → paper → minimal capital.

Build progress2 of 11 phases shipped · 18%

In progress: Phase 3 · Integrations & observability foundation

2 / 11Phases shipped
NoneCurrent trading stateNo capital, no orders yet
Integrations & observability foundationNext phase

The phases

  1. Phase 1 · FoundationMonorepo, web app, Convex, FastAPI, VPS + Traefik, CI/CD, logs & monitoring, tables
  2. Phase 2 · Application shell & consoleAuthenticated app shell: collapsible grouped sidebar, profile + logout, account/settings, dashboard & charts, dark mode
  3. Phase 3 · Integrations & observability foundationExternal connectors, secrets, provider budgets, AI/API usage logs, model registry, cost dashboards
  4. Phase 4 · Early token detectionChain / launchpad / pool collectors, first-liquidity & first-trade, lifecycle engine, tables & Parquet
  5. Phase 5 · Security & sellabilityDeterministic scanners, sell simulation, hard blockers — before any AI synthesis
  6. Phase 6 · Quantitative core & featuresDeterministic versioned formula engine, feature registry, Signal/Risk scores
  7. Phase 7 · Agent researchLangGraph workflows, launch/wallet/social agents, memory, debate & risk, AI score
  8. Phase 8 · Model routing & cost governanceDeterministic task detection, per-task benchmarks, validated hybrid routing, cost caps
  9. Phase 9 · Shadow explorationHypothetical decisions on live data, early snapshots, multi-window outcomes, weekly reports
  10. Phase 10 · Paper tradingRealistic event-driven execution simulation + strategy competition
  11. Phase 11 · Controlled productionIsolated execution, minimal capital, kill switch, reconciliation, human governance

Phase detail

Trading: none

Phase 1 · Foundation

Done

Monorepo, web app, Convex, FastAPI, VPS + Traefik, CI/CD, logs & monitoring, tables

Monorepo & tooling
  • pnpm workspaces + Turborepo
  • Shared ESLint / TypeScript / Prettier presets (packages/config)
  • ESLint architecture boundaries (feature isolation)
  • Conventional Commits + commitlint + lint-staged + Husky
Web app (TanStack Start)
  • SSR + file-based routing
  • Landing, auth and docs surfaces (~60 docs pages: sidebar, search, ToC scrollspy)
  • The "island" design system (Tailwind v4 + CSS tokens)
Backend (Convex self-hosted)
  • Control plane: schema, queries, mutations, actions
  • Auth (@convex-dev/better-auth) isolated behind features/auth + requireUser
  • Generated API as the only frontend ↔ backend contract
Python service & data
  • FastAPI service (/health, /ready) wired to Redis on the private clawlas_data network
  • Shared Zod package (packages/shared) as the single source of types
  • SQLite (local state), Redis (streams/queue), demo tasks table (reference slice)
Infra & deployment
  • Docker Compose (clawlas project, isolated networks/volumes)
  • Traefik reverse proxy on the Hostinger VPS (*.clawlas.com, TLS)
  • CI/CD on push → main via GHCR (ci.yml → deploy.yml → deploy.sh)
Observability
  • Structured logs
  • Monitoring (service health, metrics)
  • Off-host restic backups as the migration unit
Trading: none

Phase 2 · Application shell & console

Done

Authenticated app shell: collapsible grouped sidebar, profile + logout, account/settings, dashboard & charts, dark mode

App shell & navigation
  • Routed authenticated area (/app) gated by the auth boundary
  • Collapsible icon rail + grouped sidebar nav, sticky header, mobile drawer
  • User profile block (avatar, name, role) with Log out; role-gated nav items
Account & settings
  • Identity (editable display name, verified email badge, role)
  • Preferences (theme) and Security (change password, active sessions with revoke)
  • Usage & Subscription stubs pending cost collection (Phase 3) and billing
  • Sign out from the account footer
Dashboard & charts
  • Dashboard with stat cards and charts (ECharts + Lightweight Charts)
  • SSR-safe chart wrappers reused across pages
Design system
  • Console primitives: Button/Spinner in packages/ui; Badge, Card, Field, StatCard app-local until reused thrice
  • Theme provider + dark-mode toggle (light/dark tokens already authored)
Trading: none

Phase 3 · Integrations & observability foundation

In progress

External connectors, secrets, provider budgets, AI/API usage logs, model registry, cost dashboards

External integrations
  • Connector / VenueAdapter layer driven by a discovery-source catalogue
  • Chain RPC clients (Solana / EVM) and data providers
  • Rate-limit handling, retries and provider fallback
Secrets & access
  • Per-service credential management (least privilege, read-only where possible)
  • No execution keys at this stage
  • Secrets live Convex-side / in env — never in code, prompts or logs
Usage & cost observability
  • AI usage logs and API usage logs
  • Cash-cost and allocated-cost formulas
  • Provider budgets and execution-cost estimates
Model registry
  • Versioned provider/model catalogue (capabilities, pricing, limits)
  • No routing policy yet — that lands in Phase 8
Dashboards & alerting
  • Cost, data-freshness and service/source health dashboards
  • Alert thresholds (provider error rate, max API spend, stale data)
Trading: none

Phase 4 · Early token detection

Planned

Chain / launchpad / pool collectors, first-liquidity & first-trade, lifecycle engine, tables & Parquet

Collectors (isolated processes)
  • collector-solana-launches, collector-evm-contracts, collector-dex-pools
  • collector-launchpads, collector-liquidity, collector-cex-listings
  • One source failing must not stop the others
Event detection
  • Contract deployment, mint, pool creation, bonding curve
  • First liquidity, first swap, migration init/complete
  • CEX listing/activation, abnormal transaction/liquidity growth
Processing pipeline
  • Event normalization → token identity resolution (chain + contract)
  • Lifecycle engine: DISCOVERED → CONTRACT_DEPLOYED → WAITING_FOR_LIQUIDITY → EARLY_TRADABLE → LAUNCHPAD_ACTIVE → MIGRATING → DEX_ACTIVE → CEX_* → ESTABLISHED / INACTIVE / FAILED / RUGGED
Data & UI
  • Tables tokens / token_contracts / pools / events (immutable events) + lifecycle timestamps
  • Parquet archive + DuckDB queries, data-maturity levels (MINIMAL / EARLY / PARTIAL / MATURE)
  • Detection dashboard (live flow, lifecycle, data health)
Trading: none

Phase 5 · Security & sellability

Planned

Deterministic scanners, sell simulation, hard blockers — before any AI synthesis

Contract & token checks
  • Contract/creator verification, token-program type
  • Mint / freeze / upgrade authority, transfer restrictions, blacklist / pausable
  • Hidden or dynamic taxes, buy/sell tax, honeypot detection
Sellability & liquidity
  • Sell simulation + realistic sell quote
  • Liquidity size, lock/burn status, LP concentration, pool age
  • Holder concentration, deployer holdings, wash-trading signals
Hard blockers
  • A failed/blocked check prevents automatic entry regardless of score (machine-readable rejection codes)
  • Position size bounded by executable liquidity, not reported market cap
Trading: none

Phase 6 · Quantitative core & features

Planned

Deterministic versioned formula engine, feature registry, Signal/Risk scores

Math core (deterministic)
  • Versioned, tested formula catalogue (returns, PnL, ATR, volatility, momentum, breakout, liquidity, slippage, performance)
  • Risk-first position sizing
  • Invariant: the AI never computes an authoritative number
Feature registry
  • Launch / liquidity / wallet / transaction feature groups
  • Early momentum
  • Adaptive observation cadence (T+5s … T+30d, accelerating on events)
Scoring & backtests
  • Signal Score and Risk Score (deterministic)
  • Historical datasets
  • Initial backtests (no look-ahead, realistic costs, walk-forward)
Trading: none

Phase 7 · Agent research

Planned

LangGraph workflows, launch/wallet/social agents, memory, debate & risk, AI score

Agents & orchestration
  • LangGraph orchestration
  • Launch Analysis / Wallet / Social agents (evidence, never the sole trigger)
  • The AI never executes (LLM-never-executes path)
Memory & reasoning
  • SQLite memory retrieval (+ vector memory)
  • Structured research reports
  • Debate & risk workflows, AI Score / Memory Score
Trading: none

Phase 8 · Model routing & cost governance

Planned

Deterministic task detection, per-task benchmarks, validated hybrid routing, cost caps

Routing
  • Deterministic task detection before any model call
  • Low-cost cloud baseline, local/OSS model in shadow mode
  • Local-first routing only after benchmark validation, with one controlled escalation path
Cost governance
  • Task-specific quality and latency benchmarks
  • Per-task step, latency and cost ceilings
Trading: shadow

Phase 9 · Shadow exploration

Planned

Hypothetical decisions on live data, early snapshots, multi-window outcomes, weekly reports

Live observation
  • Hypothetical decisions on live data (Ignore / Watch / Simulate / Review)
  • Detailed early snapshots, multi-window outcome tracking
  • Strategy comparison and weekly knowledge reports
Trading: paper

Phase 10 · Paper trading

Planned

Realistic event-driven execution simulation + strategy competition

Execution simulation
  • Event-driven simulator with realistic assumptions: slippage, latency, failed tx, gas, partial fills, emergency exits
  • Simulated positions and strategy competition
  • Performance reporting and reconciliation of theoretical fills
Trading: limited live

Phase 11 · Controlled production

Planned

Isolated execution, minimal capital, kill switch, reconciliation, human governance

Controlled execution
  • Isolated execution credentials (trading-only, withdrawals off, IP-restricted, code-only)
  • Minimal capital, strict exposure limits, continuous sellability
  • Global kill switch, full reconciliation, append-only audit log
  • Human governance — the platform proposes, the human governs
Foundations before any trade
Done Foundation is shipped. Next Integrations & observability (external connectors, secrets, usage/cost logging, a thin model registry) is the active phase — it makes data collection and later AI work measurable and safe. Full model routing, the agent runtime and the complete math engine are intentionally deferred until there is data and validated benchmarks to justify them.