Sprint #1

Our current sprint PRD.

Product Overview & Vision

Replicats is an AI-driven trading framework that goes beyond typical “Crypto AI Agents” by combining:

• Predictive Analytics: Using time-series models for price forecasting with quantiles.

• Workflow Orchestration: Trigger-based execution of agents (e.g., scheduled checks, on-chain data events).

• Embedded Wallets: Automated (or user-approved) buy/sell transactions on both EVM and Solana networks.

• Copy-Trading: Users can “fork” or copy-trade an existing agent (e.g., “Replicat-ONE”) and view PNL in a dashboard.

Primary Goals of the v0 Prototype

1. Implement a Trigger & Workflow System: Distinct from the web dashboard, enabling agent logic to fire automatically when certain conditions are met.

2. Demonstrate Replicat-ONE: A hard-coded strategy/agent that uses forecast data and on-chain metrics to make trading decisions.

3. Allow Copy-Trading: Users can “fork” Replicat-ONE in the dashboard, letting them replicate trades in their own embedded wallets.

4. Show Trading History & PNL: Provide a simple interface to view the original agent’s and the user’s forked-agent’s transactions and performance.

Key Components

1. Data Ingestion & Database

   • Regularly fetch raw market data from Data sources.

   • Store the data in a database.

   • Provide a Pub/Sub or event indicating data changes so agents can react (if relevant).

2. Forecasting Module

   • A separate service (likely containerized in Python) that runs our models every X minutes (e.g., hourly).

   • Reads the latest price data from the database, generates forecasts (median, 5–95% quantiles), and writes them back to a “forecasts” table.

   • Emits an event/message when new forecasts are available.

3. Agent Execution Service (Workflows & Triggers)

   • Core: A job or microservice that runs continuously, listening for triggers (changes in DB, new forecasts, scheduled intervals).

   • Workflow Logic:

     1. Define triggers (e.g., “If new coin on Solana has < $1M market cap but > 500 holders,” or “Run this Dune query every 15 min,” or “When forecast probability of 5× > 20%”).

     2. Execute agent logic upon triggers (buy, sell, or more complex workflows).

   • Replicat-ONE: A special agent (hard-coded) that trades based on the forecasting data.

   • Copy-Trading:

     • If a user has chosen to copy-trade Replicat-ONE, the same actions are triggered on the user’s embedded wallet.

4. Dashboard (Next.js + tRPC)

   • Authentication & Wallet Management: Uses wallet infrastructure to create 2 embedded wallets (EVM & Solana). Users can also fund/withdraw.

   • “Fork” or Copy-Trading UI: A toggle/button to replicate Replicat-ONE.

   • Transaction & PNL View:

     • Show Replicat-ONE’s trade history and performance (PNL).

     • Show the user’s forked-agent transactions and PNL.

   • Minimal Agent Customization (Future): For v0, we only allow forking Replicat-ONE. Later, we can allow custom triggers and logic.

High-Level Architecture

                ┌────────────┐
                │  Data /    │
                │  providers │
                └─────┬──────┘
                      │(1) fetch
                      ▼
             ┌────────────────────┐
             │Data Ingestion      │
             │                    │
             └─────┬──────────────┘
                   │(2) store
                   ▼
         ┌─────────────────┐
         │   Database      │  
         └─────┬───────────┘
               │
 (scheduled)    ▼
 ┌─────────────────────────┐
 │Forecasting.             │
 │(hourly or on-demand)    │
 └─────┬───────────────────┘
       │(3) new forecasts
       │
       ▼
┌───────────────────────────┐
│Agent Execution Service    │
│ (Workflows/Triggers)      │
│  - Replicat-ONE logic     │
│  - Copy-trade replication │
└─────────┬─────────────────┘
          │(4) trades
          ▼
   ┌────────────────────┐
   │ EVM / Solana       │
   │ Embedded Wallets   │
   └────────────────────┘
          ▲
          │(5) reflect transaction
          ▼
 ┌─────────────────────────┐
 │ Next.js Dashboard       │
 │ - Sign-in w/ Dynamic.xyz│
 │ - Fork agent view       │
 │ - Transaction & PNL     │
 └─────────────────────────┘

Key Observations:

• The Agent Execution Service is separate from the Next.js frontend. It consumes triggers (from DB changes, scheduled intervals, or messages in Pub/Sub) and executes the relevant workflows.

• Forecasting can be triggered via a simple scheduler (cron) or a more sophisticated workflow tool.

• The Dashboard is primarily for user interaction (sign-in, seeing PNL, toggling copy-trade).