A dual-platform (web + mobile) astrology-based prediction system for financial assets, combining Chinese and Western astrology with AI agents for personalized predictions. The system integrates with Polymarket and offers three prediction methodologies while maintaining an entertainment-first approach.
- Payment Model: Crypto payments (SOL, ETH, USDC, USDT)
- Target Users: Crypto-native users, power users
- Features: Full access to all prediction types, advanced analytics
- Tech Stack: Next.js 14+ (App Router), React, TailwindCSS
- Payment Model: App Store/Google Play subscriptions (IAP)
- Target Users: Mainstream users, casual users
- Features: Simplified UX, quick predictions, push notifications
- Tech Stack: React Native / Expo
- Subscription Tiers:
- Free: 3 predictions/month
- Basic ($9.99/mo): 50 predictions/month
- Pro ($29.99/mo): Unlimited predictions + personalized alerts
- Framework: Node.js + Express / Fastify
- Language: TypeScript
- API: REST + WebSocket (for real-time predictions)
- Authentication: JWT + OAuth2
- Database: PostgreSQL (primary) + Redis (cache)
- Queue: BullMQ (for prediction jobs)
- AI/ML: Python microservices (FastAPI)
- Framework: Next.js 14+ (App Router)
- UI Library: React 18+
- Styling: TailwindCSS + Framer Motion (animations)
- State: Zustand / Jotai
- Forms: React Hook Form + Zod
- Charts: Recharts / TradingView widgets
- Framework: Expo (React Native)
- Navigation: Expo Router
- Payments: RevenueCat (IAP wrapper)
- Notifications: Expo Notifications
- Storage: Expo SecureStore
- LLM: Anthropic Claude / OpenAI GPT-4
- Framework: LangChain / LlamaIndex
- Vector DB: Pinecone / Weaviate (for RAG)
- Agents: Multiple specialized agents (see section 6)
-- Users & Profiles
CREATE TABLE users (
id UUID PRIMARY KEY,
email VARCHAR(255) UNIQUE,
username VARCHAR(100),
birth_date TIMESTAMP,
birth_time TIME,
birth_location JSONB, -- {lat, lng, city, country}
timezone VARCHAR(50),
created_at TIMESTAMP DEFAULT NOW(),
subscription_tier VARCHAR(50), -- free, basic, pro
subscription_expires_at TIMESTAMP
);
CREATE TABLE user_astrological_profile (
user_id UUID PRIMARY KEY REFERENCES users(id),
-- Chinese Astrology
chinese_zodiac VARCHAR(20), -- rat, ox, tiger, etc.
bazi_chart JSONB, -- Four Pillars of Destiny
favorable_elements JSONB, -- {primary: 'earth', secondary: 'fire'}
unfavorable_elements JSONB,
lucky_numbers INTEGER[],
-- Western Astrology
sun_sign VARCHAR(20),
moon_sign VARCHAR(20),
rising_sign VARCHAR(20),
birth_chart JSONB, -- full natal chart
updated_at TIMESTAMP DEFAULT NOW()
);
-- Assets & Tickers
CREATE TABLE assets (
id UUID PRIMARY KEY,
symbol VARCHAR(50) UNIQUE, -- BTC, ETH, AAPL, etc.
name VARCHAR(255),
asset_type VARCHAR(50), -- crypto, stock, commodity
category VARCHAR(100), -- DeFi, RWA, Layer1, etc.
exchange VARCHAR(100),
-- Astrological Data
birth_date TIMESTAMP, -- IPO date, token launch, etc.
birth_date_confidence VARCHAR(20), -- high, medium, low
birth_time TIME,
birth_location JSONB,
-- Chinese Astrology
primary_element VARCHAR(20), -- metal, wood, water, fire, earth
secondary_element VARCHAR(20),
bazi_chart JSONB,
-- Western Astrology
dominant_planet VARCHAR(20),
zodiac_sign VARCHAR(20),
-- Metadata
market_cap DECIMAL,
is_active BOOLEAN DEFAULT true,
created_at TIMESTAMP DEFAULT NOW(),
updated_at TIMESTAMP DEFAULT NOW()
);
-- Predictions
CREATE TABLE predictions (
id UUID PRIMARY KEY,
user_id UUID REFERENCES users(id),
prediction_type VARCHAR(50), -- macro, birth_date, divination
method VARCHAR(50), -- chinese, western, tarot, iching
-- Query
question TEXT,
target_asset_id UUID REFERENCES assets(id),
target_asset_class VARCHAR(50), -- US_stocks, HK_stocks, crypto
timeframe VARCHAR(50), -- short_term, medium_term, long_term
-- Prediction Details
prediction_result JSONB, -- structured prediction data
confidence_score DECIMAL(3,2), -- 0.00 to 1.00
favorable_score INTEGER, -- 1-10
-- AI Agent Details
agent_used VARCHAR(100),
reasoning TEXT,
recommendations JSONB,
-- Divination Specific
divination_result JSONB, -- tarot cards, iching hexagram
-- Status
status VARCHAR(50), -- pending, completed, failed
created_at TIMESTAMP DEFAULT NOW(),
completed_at TIMESTAMP
);
-- Macro Predictions (Asset Class Level)
CREATE TABLE macro_predictions (
id UUID PRIMARY KEY,
period_start DATE,
period_end DATE,
year INTEGER,
chinese_year_element VARCHAR(20), -- 2026 = fire
chinese_year_animal VARCHAR(20),
-- Predictions by Asset Class
predictions JSONB, -- {US_stocks: {score: 7, element_match: 'neutral'}, crypto: {...}}
reasoning TEXT,
created_at TIMESTAMP DEFAULT NOW()
);
-- User-Asset Compatibility
CREATE TABLE user_asset_compatibility (
id UUID PRIMARY KEY,
user_id UUID REFERENCES users(id),
asset_id UUID REFERENCES assets(id),
compatibility_score INTEGER, -- 1-10
element_harmony JSONB, -- detailed element matching
recommendations TEXT,
calculated_at TIMESTAMP DEFAULT NOW(),
UNIQUE(user_id, asset_id)
);
-- Polymarket Integration
CREATE TABLE polymarket_events (
id UUID PRIMARY KEY,
polymarket_id VARCHAR(255) UNIQUE,
title TEXT,
description TEXT,
category VARCHAR(100),
end_date TIMESTAMP,
outcomes JSONB, -- possible outcomes
current_odds JSONB,
-- Astrological Analysis
favorable_outcome VARCHAR(255),
astrological_analysis JSONB,
confidence_score DECIMAL(3,2),
last_analyzed_at TIMESTAMP,
created_at TIMESTAMP DEFAULT NOW()
);
-- Payment Transactions
CREATE TABLE transactions (
id UUID PRIMARY KEY,
user_id UUID REFERENCES users(id),
amount DECIMAL,
currency VARCHAR(20), -- SOL, ETH, USDC, USD
payment_method VARCHAR(50), -- crypto, apple_iap, google_iap
transaction_hash VARCHAR(255), -- for crypto
receipt_data TEXT, -- for IAP
status VARCHAR(50), -- pending, completed, failed
credits_granted INTEGER, -- number of predictions unlocked
created_at TIMESTAMP DEFAULT NOW()
);
-- Usage Tracking
CREATE TABLE usage_logs (
id UUID PRIMARY KEY,
user_id UUID REFERENCES users(id),
prediction_id UUID REFERENCES predictions(id),
action VARCHAR(50), -- prediction_requested, result_viewed
credits_used INTEGER,
created_at TIMESTAMP DEFAULT NOW()
);- Solana: SOL, USDC
- Ethereum: ETH, USDC, USDT
- Base: ETH, USDC
// Using Solana Pay + Phantom Wallet
import { Connection, PublicKey } from '@solana/web3.js';
import { encodeURL, createQR } from '@solana/pay';
// Pricing tiers (in USD)
const PRICING = {
credits_10: 4.99,
credits_50: 19.99,
credits_100: 34.99,
unlimited_month: 49.99
};
// Integration with Helius/QuickNode for transaction monitoring- Wallet Connect integration (Phantom, MetaMask, WalletConnect)
- QR code payments
- Transaction confirmation tracking
- Automatic credit allocation
- Failed payment retry mechanism
// Subscription tiers
const SUBSCRIPTIONS = {
free: {
predictions_per_month: 3,
features: ['basic_predictions']
},
basic: {
price: 9.99,
predictions_per_month: 50,
features: ['all_prediction_types', 'birth_chart']
},
pro: {
price: 29.99,
predictions_per_month: -1, // unlimited
features: ['all_prediction_types', 'birth_chart', 'personalized_alerts', 'polymarket_insights']
}
};- RevenueCat SDK for unified IAP
- Subscription status sync with backend
- Grace period handling
- Family sharing support
- Promotional offers
Purpose: Predict entire asset classes based on elemental cycles
# Year-based element mapping
CHINESE_YEAR_ELEMENTS = {
2024: "wood", # Dragon
2025: "wood", # Snake
2026: "fire", # Horse
2027: "fire", # Goat
2028: "earth", # Monkey
}
# Asset class element mapping
ASSET_CLASS_ELEMENTS = {
"US_stocks": ["metal", "water"],
"HK_stocks": ["fire"],
"China_stocks": ["fire"],
"crypto": ["metal", "water"],
"DeFi": ["water"],
"RWA": ["earth"],
"gold": ["metal"],
}
def calculate_macro_prediction(year, asset_class):
year_element = CHINESE_YEAR_ELEMENTS[year]
asset_elements = ASSET_CLASS_ELEMENTS[asset_class]
# Five Elements interaction logic
harmony_score = calculate_element_harmony(year_element, asset_elements)
return harmony_score # 1-10- Jupiter transits (12-year cycle) for growth sectors
- Saturn returns for consolidation
- Planetary aspects for market timing
Agent: MacroStrategyAgent
Input: Year, target asset class
Process:
1. Calculate Chinese year element
2. Analyze Western planetary transits
3. Historical backtesting correlation
4. Generate prediction report
Output: Favorability score (1-10), reasoning, best/worst periods
Purpose: Ticker-specific predictions using asset "birth dates"
// Need to establish birth dates for major assets
const ASSET_BIRTH_DATES = {
BTC: {
date: "2009-01-03", // Genesis block
confidence: "high",
alternatives: ["2008-10-31"] // Whitepaper
},
ETH: {
date: "2015-07-30",
confidence: "high"
},
AAPL: {
date: "1980-12-12", // IPO
confidence: "high"
},
// RWA tokens need research
WALRUS: {
date: null, // TO BE RESEARCHED
confidence: "unknown"
}
};def predict_asset_timing(asset, current_date):
birth_chart = calculate_birth_chart(asset.birth_date, asset.birth_location)
# Calculate transits
current_transits = get_planetary_positions(current_date)
# Find aspects
favorable_aspects = find_favorable_aspects(birth_chart, current_transits)
challenging_aspects = find_challenging_aspects(birth_chart, current_transits)
# Chinese astrology cycles
asset_bazi = calculate_bazi(asset.birth_date)
current_luck_pillar = calculate_current_luck_pillar(asset_bazi, current_date)
# Combine scores
overall_score = combine_scores(favorable_aspects, challenging_aspects, current_luck_pillar)
return prediction_reportAgent: AssetTimingAgent
Input: Asset ticker, timeframe
Process:
1. Retrieve asset birth chart
2. Calculate current transits
3. Find favorable/challenging periods
4. Generate timing recommendations
Output: Favorability score, key dates, reasoning
- Collect historical price data
- Test multiple birth date hypotheses
- Measure prediction accuracy
- Refine element mappings
- Start with top 50 market cap assets
Purpose: Short-term, position-specific guidance
class TarotPrediction:
def __init__(self):
self.deck = load_tarot_deck() # 78 cards
def three_card_spread(self, question, position_details):
"""
Past - Present - Future spread
"""
cards = self.shuffle_and_draw(3, seed=generate_seed(question, position_details))
interpretation = {
"past_influence": interpret_card(cards[0]),
"current_situation": interpret_card(cards[1]),
"future_outcome": interpret_card(cards[2]),
"overall_guidance": synthesize_reading(cards)
}
return interpretation
def celtic_cross(self, question):
"""
10-card spread for deep analysis
"""
cards = self.shuffle_and_draw(10)
# Detailed interpretation
return full_readingclass IChingPrediction:
def __init__(self):
self.hexagrams = load_hexagrams() # 64 hexagrams
def cast_hexagram(self, question, user_birth_date):
"""
Generate hexagram using date + time
"""
# Use crypto-random + user data for "casting coins"
primary_hexagram = generate_hexagram(question, user_birth_date)
changing_lines = identify_changing_lines()
future_hexagram = transform_hexagram(primary_hexagram, changing_lines)
interpretation = {
"current_hexagram": primary_hexagram,
"hexagram_name": self.hexagrams[primary_hexagram]["name"],
"judgement": self.hexagrams[primary_hexagram]["judgement"],
"image": self.hexagrams[primary_hexagram]["image"],
"changing_lines": interpret_changing_lines(changing_lines),
"future_hexagram": future_hexagram,
"guidance": synthesize_iching_reading(primary_hexagram, future_hexagram)
}
return interpretationUser Input:
- Question: "Will Maple Finance help me earn $5000 profit by end of December?"
- Current position: Long 10,000 tokens @ $0.50
- Target: $1.00 (+$5000 profit)
- Method: I Ching
Output:
- Hexagram: #14 大有 (Possession in Great Measure)
- Changing to: #26 大畜 (Great Accumulation)
- Interpretation: Strong favorable energy, but timing is key.
Best to hold through mid-month turbulence.
Peak period: Dec 18-25.
- Confidence: 7/10
Agent: DivinationAgent
Input: Question, position details, method (tarot/iching)
Process:
1. Parse question and extract key elements
2. Perform divination (tarot spread or I Ching casting)
3. Interpret symbols in financial context
4. Generate actionable guidance
Output: Reading result, confidence, recommendations
def calculate_user_profile(birth_date, birth_time, birth_location):
"""
Generate comprehensive astrological profile
"""
profile = {
# Chinese Astrology
"chinese_zodiac": calculate_chinese_zodiac(birth_date),
"bazi_chart": calculate_four_pillars(birth_date, birth_time),
"favorable_elements": extract_favorable_elements(bazi_chart),
"unfavorable_elements": extract_unfavorable_elements(bazi_chart),
"lucky_numbers": calculate_lucky_numbers(bazi_chart),
# Western Astrology
"sun_sign": calculate_sun_sign(birth_date),
"moon_sign": calculate_moon_sign(birth_date, birth_time, birth_location),
"rising_sign": calculate_rising_sign(birth_date, birth_time, birth_location),
"birth_chart": calculate_natal_chart(birth_date, birth_time, birth_location),
"dominant_elements": analyze_elemental_balance(birth_chart),
"chart_patterns": identify_chart_patterns(birth_chart)
}
return profiledef calculate_compatibility(user_profile, asset):
"""
Match user's favorable elements with asset elements
"""
# Element harmony scoring
element_score = 0
# Chinese approach
if asset.primary_element in user_profile.favorable_elements:
element_score += 5
if asset.secondary_element in user_profile.favorable_elements:
element_score += 3
if asset.primary_element in user_profile.unfavorable_elements:
element_score -= 4
# Western approach
planet_score = calculate_planet_compatibility(
user_profile.birth_chart,
asset.dominant_planet
)
# Combine scores
total_score = (element_score + planet_score) / 2
return {
"compatibility_score": clamp(total_score, 1, 10),
"reasoning": generate_compatibility_explanation(),
"recommendations": generate_recommendations()
}User Dashboard Features:
1. "Assets Best For You" - Top 10 compatible tickers
2. "Timing Calendar" - Favorable/unfavorable periods
3. "Element Alerts" - When favorable element periods begin
4. "Personal Transit Updates" - Major planetary transits affecting user
Example Output:
Your Astrological Profile:
- Favorable Elements: Earth, Fire
- Chinese Zodiac: Dragon (Earth)
- Sun: Taurus, Moon: Leo, Rising: Capricorn
Top Assets For You:
1. WALRUS (RWA) - 9/10 compatibility - Earth element
2. RENDER (GPU) - 8/10 compatibility - Fire element (energy)
3. ONDO (RWA) - 8/10 compatibility - Earth element
4. SOL - 7/10 compatibility - Fire element (fast, hot)
Avoid:
1. PENDLE - 3/10 compatibility - Water element (time decay)
2. Memecoins - 2/10 compatibility - Wind element (volatile)
interface AstroAgent {
name: string;
specialty: string;
model: 'claude-3.5-sonnet' | 'gpt-4';
systemPrompt: string;
tools: Tool[];
}
const AGENTS: AstroAgent[] = [
{
name: "MacroStrategyAgent",
specialty: "Asset class and market cycle predictions",
systemPrompt: `You are an expert in financial astrology focusing on macro trends...`,
tools: ['element_calculator', 'planetary_transit_analyzer', 'backtesting_engine']
},
{
name: "AssetTimingAgent",
specialty: "Individual ticker timing and analysis",
systemPrompt: `You analyze birth charts of financial assets...`,
tools: ['birth_chart_calculator', 'transit_finder', 'aspect_analyzer']
},
{
name: "DivinationAgent",
specialty: "Tarot and I Ching readings for specific questions",
systemPrompt: `You provide divination-based guidance...`,
tools: ['tarot_deck', 'iching_oracle', 'interpretation_engine']
},
{
name: "PersonalizationAgent",
specialty: "User-asset compatibility matching",
systemPrompt: `You match users with compatible assets based on their birth charts...`,
tools: ['compatibility_calculator', 'element_matcher', 'recommendation_engine']
},
{
name: "PolymarketAgent",
specialty: "Event prediction using astrological methods",
systemPrompt: `You predict outcomes of Polymarket events...`,
tools: ['event_analyzer', 'outcome_predictor', 'polymarket_api']
},
{
name: "ExplanationAgent",
specialty: "Converting astrological concepts to user-friendly language",
systemPrompt: `You translate complex astrological analysis into clear, entertaining explanations...`,
tools: ['simplification_engine', 'analogy_generator']
}
];class AgentOrchestrator {
async processPredictionRequest(request: PredictionRequest): Promise<PredictionResult> {
// Step 1: Route to appropriate primary agent
const primaryAgent = this.selectPrimaryAgent(request.type);
// Step 2: Primary agent generates initial prediction
const initialPrediction = await primaryAgent.execute(request);
// Step 3: Consultation with supporting agents
const enrichedPrediction = await this.enrichWithSupportingAgents(
initialPrediction,
request
);
// Step 4: ExplanationAgent translates to user-friendly format
const finalResult = await this.agents.ExplanationAgent.translate(
enrichedPrediction,
request.userLevel // beginner, intermediate, advanced
);
// Step 5: Generate animation script for frontend
const animationScript = this.generateAnimationScript(finalResult);
return {
prediction: finalResult,
confidence: enrichedPrediction.confidence,
reasoning: finalResult.explanation,
visualElements: animationScript,
supportingData: enrichedPrediction.data
};
}
private selectPrimaryAgent(requestType: string): AstroAgent {
const agentMap = {
'macro': 'MacroStrategyAgent',
'birth_date': 'AssetTimingAgent',
'divination': 'DivinationAgent',
'compatibility': 'PersonalizationAgent',
'polymarket': 'PolymarketAgent'
};
return this.agents[agentMap[requestType]];
}
}# Vector database for astrological knowledge
class AstroKnowledgeBase:
def __init__(self):
self.vectordb = PineconeClient()
self.embeddings = OpenAIEmbeddings()
# Pre-loaded knowledge
self.collections = {
"chinese_astrology": "Bazi, Chinese zodiac, 5 elements theory",
"western_astrology": "Natal charts, transits, aspects",
"tarot": "78 cards meanings and interpretations",
"iching": "64 hexagrams and changing lines",
"financial_astrology": "Historical correlations and patterns",
"asset_data": "Ticker birth dates, element classifications"
}
def query(self, question, context):
"""
Retrieve relevant knowledge for agent reasoning
"""
relevant_docs = self.vectordb.similarity_search(
question,
k=5,
filter={"collection": self.determine_collection(context)}
)
return relevant_docs// Polymarket API Integration
class PolymarketService {
async fetchActiveEvents(): Promise<PolymarketEvent[]> {
// Categories of interest
const categories = [
'crypto',
'stocks',
'politics',
'economics',
'sports'
];
const events = await this.polymarketAPI.getEvents({
categories,
status: 'active',
minLiquidity: 10000
});
return events;
}
async analyzeEvent(event: PolymarketEvent): Promise<AstroAnalysis> {
// Determine relevant astrological factors
const eventDate = event.endDate;
const eventType = event.category;
// Get astrological conditions for event date
const planetaryConditions = await this.calculatePlanetaryConditions(eventDate);
const chineseDate = await this.convertToChineseDateElements(eventDate);
// Match event type to astrological factors
const relevantFactors = this.matchEventToAstrology(eventType, planetaryConditions);
// Generate prediction
const prediction = await this.agents.PolymarketAgent.predict({
event,
planetaryConditions,
chineseDate,
relevantFactors
});
return prediction;
}
}def analyze_event_asset_correlation(polymarket_event, assets):
"""
Match Polymarket events to affected assets
Example: "Will BTC reach $100k by Dec 2025?" -> BTC asset
"""
# NLP extraction
mentioned_assets = extract_assets_from_text(polymarket_event.title)
# Indirect correlations
if "interest rates" in polymarket_event.title.lower():
mentioned_assets.extend(["Gold", "Bonds", "Real Estate REITs"])
if "china economy" in polymarket_event.title.lower():
mentioned_assets.extend(["Chinese stocks", "BABA", "BIDU"])
# Generate predictions for each asset
predictions = []
for asset in mentioned_assets:
prediction = predict_asset_timing(asset, polymarket_event.endDate)
predictions.append({
"asset": asset,
"event_correlation": "direct" or "indirect",
"prediction": prediction
})
return predictionsPolymarket Features for Users:
1. "Astrologically Favorable Bets" - Events with high confidence predictions
2. "Event Calendar" - Upcoming events with astrological analysis
3. "Outcome Predictions" - AI agent predictions with reasoning
4. "Alert Me" - Notifications when favorable opportunities arise
Landing Page
↓
Sign Up / Login
↓
Onboarding (collect birth date/time/location)
↓
Main Dashboard
├── Quick Prediction (form + question input)
├── My Predictions (history)
├── Personalized Insights (compatible assets)
├── Polymarket Events
└── Settings
Quick Prediction Flow:
1. Select Prediction Type:
- Macro (asset class)
- Asset Timing (specific ticker)
- Divination (personal question)
- Polymarket Event
2. Input Details:
- [Macro] Select asset class, timeframe
- [Asset Timing] Enter ticker, timeframe
- [Divination] Type question, position details
- [Polymarket] Select event
3. AI Agent Processing:
- Show animation (agent "thinking")
- Visual: Oracle/crystal ball/cosmic animation
- Progress indicators
- Fun messages: "Consulting the stars...", "Aligning elements..."
4. Results Display:
- Overall score (1-10 scale with visual gauge)
- Key insights (bullet points)
- Detailed reasoning (expandable)
- Charts/visualizations
- Recommendations
- Share button
// Framer Motion animations
const PredictionAnimation = () => {
const [stage, setStage] = useState('consulting');
const stages = [
{
name: 'consulting',
visual: 'cosmos_spiral',
message: 'Consulting the cosmic energies...',
duration: 2000
},
{
name: 'calculating',
visual: 'element_symbols_floating',
message: 'Calculating elemental harmony...',
duration: 2000
},
{
name: 'analyzing',
visual: 'birth_chart_overlay',
message: 'Analyzing planetary transits...',
duration: 2000
},
{
name: 'synthesizing',
visual: 'oracle_reveal',
message: 'Synthesizing insights...',
duration: 1500
},
{
name: 'complete',
visual: 'result_card_appear',
message: 'Your prediction is ready!',
duration: 0
}
];
return (
<AnimatedOracle
stages={stages}
onComplete={showResults}
/>
);
};// Component library
const components = {
// Forms
BirthChartForm: 'Collect user birth details',
PredictionRequestForm: 'Multi-step form for predictions',
// Visualizations
ElementHarmonyGauge: 'Visual gauge showing element compatibility',
AstroScoreCard: '1-10 score with cosmic design',
TimingCalendar: 'Calendar showing favorable/unfavorable dates',
BirthChartWheel: 'Interactive natal chart visualization',
TarotCardDisplay: 'Animated tarot card reveal',
IChingHexagram: 'Interactive hexagram with changing lines',
// Dashboards
PersonalizedAssetList: 'List of compatible assets',
PolymarketEventCard: 'Event with astrological prediction',
PredictionHistoryList: 'Past predictions with outcomes',
// Animations
CosmicLoadingAnimation: 'Oracle consulting animation',
ElementTransitionEffect: 'Element symbols flowing',
PlanetOrbitAnimation: 'Planetary transit visualization'
};Goal: Basic infrastructure and authentication
Tasks:
1. Initialize project structure
- Next.js web app setup
- Expo mobile app setup
- Node.js backend API setup
- PostgreSQL database setup
2. Authentication system
- JWT implementation
- OAuth2 (Google, Apple)
- Session management
3. Database schema
- Create all tables
- Set up migrations
- Seed initial data
4. Basic UI components
- Design system setup (TailwindCSS)
- Landing page
- Sign up / Login pages
- Dashboard shell
Deliverable: Users can sign up, log in, see empty dashboard
Goal: Core astrological calculation system
Tasks:
1. Chinese astrology calculator
- Bazi (Four Pillars) calculator
- Chinese zodiac
- Element extraction
- Lucky numbers
2. Western astrology calculator
- Natal chart calculation (using Swiss Ephemeris)
- Sun/Moon/Rising signs
- Planetary positions
- Aspects finder
3. User profile creation
- Birth chart input form
- Profile generation
- Element analysis
- Store in database
4. Asset birth date research
- Research top 50 crypto assets
- Research top 50 stocks
- Document birth dates and confidence levels
- Create asset profiles in database
Deliverable: Users can create astrological profiles, view their birth charts
Goal: First prediction type working end-to-end
Tasks:
1. MacroStrategyAgent implementation
- Year element calculator
- Asset class element mapping
- Harmony scoring algorithm
- Prediction reasoning generator
2. Backtesting framework
- Historical data collection
- Test macro predictions vs actual performance
- Refine element mappings
3. Frontend for macro predictions
- Asset class selection UI
- Timeframe selection
- Animation during processing
- Results display page
4. Database integration
- Store predictions
- Track accuracy over time
Deliverable: Users can request macro predictions and see results
Goal: Asset timing predictions
Tasks:
1. AssetTimingAgent implementation
- Transit calculator
- Aspect finder
- Timing analysis
- Chinese luck pillar calculator
2. Asset search and selection
- Asset search UI
- Asset detail pages
- Birth chart visualization
3. Backtesting for top assets
- Test birth date hypotheses
- Validate predictions vs historical price action
- Iterate on methodology
4. Timing calendar UI
- Calendar view of favorable/unfavorable periods
- Key date highlights
- Export to personal calendar
Deliverable: Users can get timing predictions for specific assets
Goal: Tarot and I Ching predictions
Tasks:
1. Tarot system
- Digital tarot deck (78 cards)
- Spread layouts (3-card, Celtic Cross)
- Interpretation engine
- Card animation
2. I Ching system
- 64 hexagrams database
- Casting algorithm
- Changing lines logic
- Interpretation engine
3. DivinationAgent implementation
- Question parser
- Context-aware interpretation
- Financial application of readings
4. UI components
- Question input form
- Card/hexagram reveal animation
- Reading display
Deliverable: Users can ask specific questions and receive tarot/I Ching guidance
Goal: User-asset matching system
Tasks:
1. Compatibility algorithm
- Element matching logic
- Planet compatibility
- Scoring system
2. PersonalizationAgent
- User profile analysis
- Asset recommendation engine
- Explanation generator
3. Personalized dashboard
- "Best Assets For You" list
- Compatibility scores
- Recommendations
4. Batch processing
- Calculate compatibility for all assets
- Update regularly
- Cache results
Deliverable: Users see personalized asset recommendations
Goal: Event predictions
Tasks:
1. Polymarket API integration
- Fetch active events
- Parse event details
- Track odds
2. PolymarketAgent implementation
- Event analyzer
- Outcome predictor
- Correlation finder
3. Event dashboard
- List of events
- Astrological predictions
- Alert system
4. User betting guidance
- Favorable events
- Confidence scores
- Track record
Deliverable: Users can see astrological predictions for Polymarket events
Goal: Monetization infrastructure
Tasks:
1. Web crypto payments
- Solana Pay integration
- Ethereum wallet integration
- Transaction monitoring
- Credit system
2. Mobile IAP
- RevenueCat integration
- Subscription tiers
- Receipt validation
- Sync with backend
3. Usage tracking
- Credit consumption
- Rate limiting
- Subscription validation
4. Admin panel
- Transaction monitoring
- Revenue analytics
- User subscription management
Deliverable: Users can purchase credits/subscriptions
Goal: Multi-agent orchestration and RAG
Tasks:
1. Agent framework setup
- LangChain integration
- Agent registry
- Orchestrator implementation
2. RAG system
- Vector database setup (Pinecone)
- Knowledge base ingestion
- Retrieval logic
3. ExplanationAgent
- Translation to user-friendly language
- Entertainment tone
- Skill level adaptation
4. Agent monitoring
- Performance tracking
- Cost monitoring
- Quality assurance
Deliverable: Cohesive multi-agent system with intelligent orchestration
Goal: Feature parity and mobile-specific features
Tasks:
1. Port all prediction features to mobile
- Simplified forms
- Mobile-optimized animations
- Touch interactions
2. Mobile-specific features
- Push notifications (favorable periods)
- Widget (daily outlook)
- Biometric auth
3. Offline support
- Cache predictions
- Sync when online
- Graceful degradation
4. App Store preparation
- Screenshots
- App preview videos
- Store listings
- Review compliance
Deliverable: Fully functional mobile app ready for submission
Goal: Bug fixing, performance optimization
Tasks:
1. Comprehensive testing
- Unit tests (80%+ coverage)
- Integration tests
- E2E tests (Playwright)
- Mobile testing (iOS + Android)
2. Performance optimization
- Database query optimization
- Caching strategy
- API response times
- Bundle size reduction
3. Security audit
- Penetration testing
- Dependency audit
- Authentication security
- Payment security
4. User feedback integration
- Beta testing (50-100 users)
- Bug fixes
- UX improvements
Deliverable: Production-ready, tested, optimized system
Goal: Public launch and continuous improvement
Tasks:
1. Soft launch
- Limited user access
- Monitor errors
- Quick fixes
2. Marketing
- Social media
- Content creation
- Partnerships (crypto influencers)
3. Analytics
- User behavior tracking
- Prediction accuracy monitoring
- Revenue tracking
4. Iteration
- Feature requests
- A/B testing
- Model improvements
- Expand asset coverage
Deliverable: Live product with growing user base
⚠️ ENTERTAINMENT PURPOSES ONLY
This application provides astrological predictions for entertainment purposes only.
Predictions are not financial advice and should not be used as the sole basis for
financial decisions. Past performance does not indicate future results.
Cryptocurrency and stock investments carry risk. Only invest what you can afford to lose.
By using this service, you acknowledge that astrological predictions are speculative
and that you are responsible for your own financial decisions.
Phase 1 (Months 1-6): Entertainment Focus
- Emphasize fun, exploration, curiosity
- Disclaimers on every page
- No direct "buy/sell" recommendations
- Track prediction accuracy transparently
Phase 2 (Months 6-12): Education
- Educational content on astrology + finance
- Blog posts explaining methodologies
- Transparency reports on accuracy
- Community feedback integration
Phase 3 (Year 2+): Potential Evolution
- If accuracy is proven, consider:
- Partnerships with regulated entities
- Compliance consultation
- Additional disclaimers
- Insurance coverage
GDPR & Privacy Compliance:
- Birth dates are sensitive data
- Encryption at rest and in transit
- User data deletion option
- Export user data option
- Clear privacy policy
- Cookie consent
- No sale of user data
User Acquisition:
- Target: 10,000 users in first 6 months
- CAC < $20
- Viral coefficient > 1.2
Engagement:
- DAU/MAU > 30%
- Average 10 predictions per user per month
- Session length > 5 minutes
Retention:
- D1: 40%, D7: 25%, D30: 15%
- Subscription churn < 5% per month
Revenue:
- Target: $50k MRR by month 12
- ARPU > $15/month
- LTV/CAC ratio > 3
Backtesting Benchmarks:
- Macro predictions: >55% accuracy (vs 50% random)
- Asset timing: >52% accuracy on directional calls
- Divination: Subjective user satisfaction >70%
Real-time Tracking:
- Log all predictions
- Compare to actual outcomes
- Monthly accuracy reports
- Iterate on methodologies
Performance:
- API response time < 500ms (p95)
- Prediction generation < 10 seconds
- Uptime > 99.5%
Cost:
- LLM API costs < 20% of revenue
- Infrastructure costs < 15% of revenue
- Total COGS < 40%
Frontend Web:
- Next.js 14+
- React 18
- TypeScript
- TailwindCSS
- Framer Motion
- Zustand
Frontend Mobile:
- Expo (React Native)
- TypeScript
- RevenueCat
Backend:
- Node.js + TypeScript
- Express / Fastify
- PostgreSQL
- Redis
- BullMQ
AI/ML:
- Python + FastAPI
- Anthropic Claude
- OpenAI GPT-4
- LangChain
- Pinecone
Payments:
- Solana Pay
- Phantom Wallet
- MetaMask
- RevenueCat (IAP)
Infrastructure:
- Vercel (web hosting)
- Railway / Render (backend)
- Supabase / Neon (PostgreSQL)
- Upstash (Redis)
Astrology Libraries:
- Swiss Ephemeris (planetary calculations)
- Custom Bazi calculator
- Custom Tarot/I Ching engines
APIs:
- Polymarket API
- CoinGecko / CoinMarketCap
- Alpha Vantage (stocks)
- Helius / QuickNode (Solana)-
Finalize Tech Stack Decision
- Confirm all technology choices
- Set up development environments
-
Repository Setup
# Monorepo structure /astro /apps /web # Next.js /mobile # Expo /api # Node.js backend /ml-engine # Python AI services /packages /ui # Shared components /astro-core # Astrological calculations /database # Prisma schema /types # Shared TypeScript types /docs # Documentation
-
Team Requirements
- Frontend Developer (React/Next.js)
- Backend Developer (Node.js/TypeScript)
- ML Engineer (Python/LangChain)
- Astrologer Consultant (part-time)
- UI/UX Designer
- DevOps Engineer (part-time)
-
Initial Research Tasks
- Asset birth date research (top 50 crypto + stocks)
- Astrological knowledge base compilation
- Polymarket API exploration
- Payment provider evaluation
This is an ambitious, innovative project combining ancient wisdom with modern AI and blockchain technology. The phased approach ensures we can validate core concepts early while building toward a comprehensive platform.
Key Success Factors:
- Start simple, iterate based on user feedback
- Maintain entertainment positioning to avoid regulatory issues
- Focus on prediction accuracy and transparency
- Build delightful, engaging UX
- Community-driven development
Timeline: 7-8 months to full launch Estimated Budget: $150k-$200k (team + infrastructure) Potential Market: Crypto natives, astrology enthusiasts, prediction market users
Let's build something magical! 🌟