HORIZON ONE

Predictive Behavioral Intelligence for Strategic Decision-Making

Simulate thousands of AI-driven synthetic personas. Predict market sentiment. Forecast revenue impact. All before a single dollar is spent.

One-Click Install · How It Works · Architecture · Features · Documentation · License

---

The Problem

Traditional market research is slow, expensive, and backward-looking. By the time survey data is analyzed, the cultural conversation has already shifted.

Focus groups can't predict viral dynamics. Spreadsheets can't model human stubbornness. Historical data is blind to novel events.

When a competitor drops prices while running a viral campaign—when a PR crisis hits during a product launch—when influencer sentiment shifts overnight—you need to see around corners.

The Solution

Horizon One is an enterprise-grade agent-based simulation platform that bridges the gap between soft human sentiment and hard commercial outcomes.

Instead of asking a single AI what millions of people might do, Horizon One creates a digital sandbox populated with thousands of distinct synthetic personas—each with unique demographics, psychographics, financial constraints, and social connections—and lets you watch what happens when you inject a real-world strategic event.

┌─────────────────────────────────────────────────────────────────┐
│                                                                 │
│    "What if we launch this campaign next quarter?"              │
│                                                                 │
│         ┌──────────┐     ┌──────────┐     ┌──────────┐         │
│         │ 10,000   │────▶│ Simulate │────▶│ Revenue  │         │
│         │ Personas │     │ 52 Weeks │     │ Forecast │         │
│         └──────────┘     └──────────┘     └──────────┘         │
│                                                                 │
│    Predicted Penetration: 12.4%    ROAS: 3.2x    CPA: $18.40  │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

✨ Features

🧠 Four-Tier Cognitive Engine Scale intelligence vs. cost with four simulation fidelity levels: Level 1 — Stochastic math for 10,000+ agents instantly Level 2 — LLM-powered archetype group reasoning Level 3 — Individual persona chain-of-thought Level 4 — Deep iterative cognitive dissonance modeling	📊 Predictive Purchase Engine Translate sentiment into CFO-ready financials: Predicted Penetration Index — Market share capture forecast Cost Per Acquisition — Campaign efficiency scoring Return on Ad Spend — Net financial surplus calculation Revenue Waterfall — Tick-by-tick cumulative projections
🌐 Agentic Research Network Live market intelligence via MCP sensor integration: DuckDuckGo — Real-time web search Google News & Trends — Trending topic analysis Web Fetch & Scraper — Deep content extraction Wikipedia — Knowledge graph enrichment	🎭 Synthetic Persona Generation High-fidelity digital humans grounded in behavioral science: OCEAN personality traits — Openness, Conscientiousness, Extraversion, Agreeableness, Neuroticism Demographic anchoring — Age, gender, region, income Social network topology — Influencer hubs and peripheral nodes Media channel affinity — Platform-specific trust weights
🔬 Advanced Analysis Suite Post-simulation strategic intelligence: Monte Carlo Risk Analysis — Probabilistic outcome ranges Counterfactual Scenarios — "What-if" branching comparisons Hindcast Validation — Backtest against historical events Calibration Engine — Auto-tune to real-world ground truth	📑 C-Suite Report Generation AI-generated strategic deliverables: Commercial Market Analysis — Full breakdown with charts Deep Research Reports — LLM-synthesized intelligence PDF Export — Professional presentation-ready output Run Comparison — Side-by-side strategy evaluation

🔧 How It Works

Horizon One operates in three phases:

Phase 1 — Population Synthesis

The Persona Generation Engine creates a demographically accurate synthetic population. Each agent receives unique OCEAN personality traits, income constraints, media habits, brand loyalty scores, and social network connections. Archetypes (e.g., "The Nostalgic Curator," "The Franchise Hunter") define behavioral templates that the LLM actors inhabit.

Phase 2 — Simulation Execution

Time advances in configurable ticks (days or weeks). At each tick:

1. The Director Model (e.g., Gemini Pro) synthesizes the global narrative context
2. Environmental vectors (media sentiment, competitor actions, injected events) propagate through the social network
3. Each agent processes stimuli through their cognitive tier and updates their opinion
4. The Behavioral Sales Model converts opinion shifts into purchase probabilities using utility calculations, price sensitivity, and competitive choice modeling

Phase 3 — Intelligence Extraction

The analysis engine aggregates thousands of individual decisions into enterprise-grade KPIs. The Predictive Purchase Engine calculates market share, revenue projections, CPA, and ROAS. Agentic Research enriches findings with real-time market data via MCP servers. AI-generated C-Suite reports synthesize everything into actionable strategy documents.

🏗 Architecture

Alpha_Horizon/
├── app/
│   ├── ui/                          # Gradio Frontend
│   │   └── pages/
│   │       ├── simulation.py        # Simulation control & monitoring
│   │       ├── analysis.py          # Predictive purchase & analytics
│   │       ├── history.py           # Run history & comparison
│   │       ├── settings.py          # LLM, MCP, & system configuration
│   │       └── help.py              # Documentation & guides
│   │
│   └── backend/
│       ├── core/                    # Engine & Managers
│       │   ├── simulation_engine.py # MESA-based ABM core
│       │   ├── persona_manager.py   # Synthetic persona generation
│       │   ├── behavioral_sales_model.py  # Sentiment → Revenue
│       │   ├── calibration_layer.py # Ground-truth auto-tuning
│       │   ├── llm_manager.py       # Multi-provider LLM orchestration
│       │   ├── mcp_registry.py      # MCP server management
│       │   ├── rag_manager.py       # Qdrant vector memory
│       │   └── ...
│       │
│       ├── analysis/                # Post-Simulation Intelligence
│       │   ├── reverse_engineer.py  # KPI extraction engine
│       │   ├── monte_carlo.py       # Probabilistic risk analysis
│       │   ├── counterfactual.py    # What-if scenario branching
│       │   ├── hindcast.py          # Historical validation
│       │   ├── agentic_research.py  # MCP-powered live research
│       │   └── commercial_report.py # C-Suite report generation
│       │
│       ├── sensors/                 # External Data Connectors
│       │   ├── mcp_client.py        # Model Context Protocol client
│       │   └── simulated_feed.py    # Synthetic media feed generator
│       │
│       └── utils/                   # Shared Utilities
│           ├── llm_dispatcher.py    # Provider-agnostic LLM routing
│           ├── llm_registry.py      # Model capability registry
│           └── llm_tools.py         # LLM function-calling tools
│
├── config/                          # Configuration
│   ├── llm_registry.yaml           # Model definitions & capabilities
│   ├── mcp_registry.yaml           # MCP server configurations
│   ├── archetypes.json             # Default persona archetypes
│   ├── media_weights.json          # Channel trust weights
│   └── prompts/                    # System prompt templates
│
├── data/                            # Runtime Data
│   ├── companies/                   # Per-company simulation data
│   └── qdrant_storage/             # Vector database (embedded)
│
├── docs/                            # Documentation & Assets
├── tests/                           # Test Suite
├── Dockerfile                       # Container deployment
├── compose.yaml                     # Docker Compose orchestration
├── requirements.txt                 # Python dependencies
├── run.sh                           # Linux/macOS launcher
├── run.bat                          # Windows launcher
├── HorizonOne-Install.bat           # One-click installer (Windows)
└── HorizonOne-Install.command       # One-click installer (macOS/Linux)

🚀 One-Click Install

Get Horizon One running in seconds — no git, no terminal, no manual setup.

Platform	Download	How to Run
Windows	📥 HorizonOne-Install.bat	Double-click the downloaded file
macOS	📥 HorizonOne-Install.command	Double-click the downloaded file
Linux	📥 HorizonOne-Install.command	Run: bash HorizonOne-Install.command

What happens: The installer checks for Python 3.10+, downloads Horizon One from GitHub, creates an isolated virtual environment, installs all dependencies, creates a desktop shortcut, and launches the application — all automatically.

Prerequisites

• Python 3.12+ — Download Python (Windows: check “Add python.exe to PATH” during install)
• At least one LLM API key (Google Gemini, OpenAI, Anthropic, or local Ollama)
• 4 GB RAM minimum (8 GB+ recommended for large populations)

What the Installer Does

┌─ Download Horizon One from GitHub
├─ Check Python 3.10+ is installed
├─ Create isolated virtual environment
├─ Install all Python dependencies
├─ Create desktop shortcut (“Horizon One”)
└─ Launch the application at http://localhost:7861

After installation, use the Horizon One desktop shortcut to launch anytime.

🔧 Manual Installation (for developers)

# Clone the repository
git clone https://github.com/AlphaHorizon-AI/Alpha_one.git
cd Alpha_one

# Create virtual environment
python -m venv .venv
source .venv/bin/activate        # Linux/macOS
# .venv\Scripts\activate         # Windows

# Install dependencies
pip install -r requirements.txt

# Launch Horizon One
./run.sh                          # Linux/macOS
# run.bat                        # Windows

The application will start on http://localhost:7861.

🐋 Docker Deployment

docker compose up --build

First Run

1. Navigate to Settings and configure your LLM provider API keys
2. Select or create a Company profile with your target market parameters
3. Go to Simulation — configure your population, cognitive level, and event injection
4. Press Run and watch thousands of synthetic personas react in real-time
5. Switch to Analysis to generate Predictive Purchase forecasts and C-Suite reports

🤖 Supported LLM Providers

Provider	Models	Use Case
Google Gemini	Gemini 2.5 Pro, Flash, etc.	Director & Actor models
OpenAI	GPT-4o, GPT-4o-mini, o1, o3	High-fidelity persona reasoning
Anthropic	Claude Sonnet, Opus, Haiku	Strategic report generation
Ollama	Llama, Mistral, DeepSeek, Qwen	Local/private deployment
OpenRouter	200+ models	Flexible multi-model routing

📖 Documentation

Document	Description
Platform Overview	Complete technical platform documentation
Whitepaper	Architectural whitepaper and methodology
Executive Whitepaper	Non-technical executive summary
LLM Configuration Guide	Setting up multi-provider LLM routing

🏢 Use Cases

🛍️ Product Launch Predict market reception, optimal pricing, and revenue impact before manufacturing begins	📢 Campaign Strategy Test marketing campaigns across synthetic demographics and measure predicted ROAS	🗳️ Political Analysis Model voter sentiment dynamics, policy impact, and election outcome probabilities
⚠️ Crisis Simulation Stress-test brand resilience against PR crises, competitor attacks, and market shocks	💰 Pricing Strategy Find the optimal price point by simulating demand elasticity across income segments	🔄 Competitive Response War-game competitor moves and discover optimal counter-strategies

⚙️ Tech Stack

Layer	Technology
Simulation Core	MESA 2.4 — Agent-based modeling framework
AI Orchestration	Multi-LLM via OpenAI-compatible API (Gemini, GPT, Claude, Ollama)
External Intelligence	Model Context Protocol (MCP) — DuckDuckGo, Google Trends, Wikipedia
Vector Memory	Qdrant — Embedded vector search with BGE embeddings
Frontend	Gradio 4.0+ — Interactive web UI with real-time streaming
Visualization	Plotly — Interactive charts, funnels, and timelines
Report Generation	ReportLab + FPDF2 — Professional PDF export
Containerization	Docker + Docker Compose

📜 License

Horizon One is released under the Horizon One Free Use License.

Free to use — not open source. You may inspect, run, evaluate, and use Horizon One internally. You may not modify the source code, fork it, rebrand it, resell it, host it as a service, or build a competing product from it.

For commercial licensing, modification rights, or enterprise deployment inquiries, contact Alpha Horizon directly.

---

Built by Alpha Horizon

Predictive Behavioral Intelligence for the Enterprise

Copyright © Alpha Horizon. All rights reserved.