Accelos - Autonomous Startup Accelerator

Accelos is a startup accelerator director platform that orchestrates external AI services and tools to validate and develop business ideas. It directs any AI provider (Claude, GPT, Gemini, or custom) and GitHub to conduct market research, develop strategy, build prototypes, and analyze experimental results—automating the core functions of startup acceleration while you maintain full control over your API credentials and costs.

Overview

Rather than having humans manually validate ideas, Accelos directs your chosen AI service that works together with other tools to:

Conduct comprehensive market research
Identify strategic pivots and opportunities
Generate working prototypes with code
Analyze experiment results and provide data-driven insights
Track idea viability scores throughout development

The system provides a dashboard-based interface for entrepreneurs to submit ideas, monitor agent activity, run experiments, and iterate on concepts in real time.

Core Features

Agent Direction & Orchestration

Accelos directs external AI services through five specialized agent roles. You provide your own API credentials—Accelos doesn't host the agents, it directs them:

Research Agent - Directs Claude to perform market analysis including market size estimation, competitor analysis, trend identification, target segment discovery, opportunity identification, and risk assessment
Strategy Agent - Directs Claude to generate strategic pivots and experimental designs based on research findings, recommend hypothesis refinements, and suggest next milestones
Builder Agent - Directs Claude to create working prototype code, then uses your GitHub credentials to publish repositories
Analyst Agent - Directs Claude to evaluate experiment results, synthesize insights, and provide viability recommendations
Orchestrator - Manages the entire workflow, coordinating agent execution and maintaining audit logs across your ideas

Dashboard (Mission Control)

Real-time overview of all ideas and their viability scores
Live agent activity monitoring and logging
Top-performing ideas leaderboard
Idea statistics (total ideas, active experiments, completed reports)
Quick navigation to create new ideas or manage existing ones

Idea Management

Submit startup ideas with title, description, hypothesis, and target user
Track ideas through development stages (seed, growth, scale)
Maintain idea iterations with version history and changelog
Tag-based organization and filtering
Automatic viability scoring (0-100)

Experiment Framework

Design and execute A/B tests, prototype tests, market research, and landing page experiments
Real-time metric tracking with custom units and variants
Experiment status lifecycle (pending, running, completed, failed)
Winner determination and insight generation
Configurable experiment parameters

Reporting & Analytics

Comprehensive idea analysis reports
Metric aggregation and visualization
Automated report generation from experiment data
Strategic recommendations based on data

Integration Support

GitHub integration for automatic prototype repository creation
Extensible framework for future integrations
Integration status monitoring and sync tracking

Tech Stack

Frontend: Next.js 15, React 18, TypeScript
Backend: Next.js API routes, TypeScript
Database: SQLite with Prisma ORM
AI Service: Anthropic Claude API (you provide your own API key)
Version Control: GitHub REST API via Octokit (you provide your own credentials)
Orchestration: Custom agent director using tool-use with Claude

Project Structure

src/
├── app/
│   ├── api/                    # API endpoints
│   │   ├── ideas/             # Idea CRUD and management
│   │   ├── experiments/       # Experiment lifecycle
│   │   ├── dashboard/         # Dashboard data aggregation
│   │   ├── integrations/      # Integration management
│   │   └── reports/           # Report generation
│   ├── ideas/                 # Idea pages
│   │   ├── page.tsx          # Ideas list view
│   │   ├── new/page.tsx      # Create new idea form
│   │   └── [id]/page.tsx     # Idea detail page with logs
│   ├── experiments/page.tsx   # Experiments management
│   ├── integrations/page.tsx  # Integration configuration
│   ├── reports/page.tsx       # Reports and analytics
│   ├── page.tsx              # Dashboard (Mission Control)
│   └── layout.tsx            # Root layout
├── lib/
│   ├── agents/               # AI agent implementations
│   │   ├── orchestrator.ts   # Workflow orchestration
│   │   ├── research.ts       # Market research agent
│   │   ├── strategy.ts       # Strategy & pivot generation
│   │   ├── builder.ts        # Prototype builder agent
│   │   └── analyst.ts        # Results analysis agent
│   └── db.ts                 # Prisma client
└── components/
    └── Sidebar.tsx           # Navigation component

prisma/
├── schema.prisma             # Database schema
└── migrations/               # Database migration history

Angular Frontend

The Angular client lives in frontend/ and uses the existing Next.js API routes unchanged.

Start the API host: npm run dev (port 3000)
In a second terminal, start Angular: npm run frontend:dev (port 4200)

Angular proxies /api requests to the Next.js host during development. Build it with npm run frontend:build. For production, serve frontend/dist/accelos-frontend/browser from your static host and route /api to the Next.js service.

Database Schema

Core Models

Idea - The central entity representing a startup concept

Basic metadata (title, description, tags)
Development stage (seed, growth, scale)
Status (active, archived, etc.)
Dynamic viability score
Related hypothesis, target user, and problem statement

IdeaIteration - Version history for ideas

Tracks changes and refinements over time
Maintains score history
Records reasoning for changes

Experiment - A/B tests and validation experiments

Hypothesis-driven design
Multiple experiment types (ab_test, market_research, prototype, landing_page)
Configuration and results storage
Winner determination

Metric - Measurement data points from experiments

Per-experiment metric tracking
Unit and variant support
Timestamped recordings

AgentRun - Audit log of all agent executions

Tracks which agent ran, when, and what it produced
Stores input/output and execution logs
Error tracking and debugging support

Report - Analysis outputs and insights

Type-based reports (research, strategy, analysis)
Content, summary, and metric aggregation
Associated with specific ideas

Integration - External service connections

Integration type and configuration
Connection status and last sync timestamp
Extensible for new integration types

Getting Started

Prerequisites

Node.js 18+ and npm/yarn/pnpm
Anthropic API key
(Optional) GitHub personal access token for prototype publishing

Installation

Clone and install dependencies:
```
npm install
```
Set up environment variables: Create a .env.local file in the project root. You must provide your own API credentials—Accelos will not work without them:
```
ANTHROPIC_API_KEY=your_anthropic_api_key_here
DATABASE_URL=file:./dev.db
# Optional: GitHub integration (for auto-publishing prototypes)
GITHUB_TOKEN=your_personal_access_token
GITHUB_USERNAME=your_github_username
```
Get your credentials:
- Anthropic API Key (Required)
  - Create a free account at console.anthropic.com
  - Generate an API key in your account settings
  - This is what Accelos will use to direct Claude
- GitHub Personal Access Token (Optional)
  - Only needed if you want prototypes auto-published to GitHub
  - Requires repo scope to create repositories
Important: If ANTHROPIC_API_KEY is missing, the app will fail when you try to run agents and show a clear error message.
Initialize the database:
```
npx prisma migrate dev
```
Start the development server:
```
npm run dev
```
Open http://localhost:3000 in your browser. If environment variables are missing, you'll see errors when you try to run agents—check the .env.local file and server logs.

Development Workflow

Create an Idea - Click "New Idea" on the dashboard and fill in the idea details
Run Agents - The orchestrator automatically runs agents against the idea (or trigger manually via API)
Monitor Progress - Watch real-time agent execution logs and progress on the idea detail page
Review Results - Check generated research, strategy recommendations, prototypes, and analysis
Run Experiments - Create and track experiments to validate hypotheses
Iterate - Use insights to refine the idea and run another cycle

API Endpoints

Ideas

GET /api/ideas - List all ideas
POST /api/ideas - Create new idea
GET /api/ideas/[id] - Get idea details
PATCH /api/ideas/[id] - Update idea
DELETE /api/ideas/[id] - Delete idea
POST /api/ideas/[id]/run - Trigger agent orchestration

Idea Logs

GET /api/ideas/[id]/logs - Get agent execution logs for an idea

Experiments

GET /api/experiments - List all experiments
POST /api/experiments - Create experiment
GET /api/experiments/[id] - Get experiment details
PATCH /api/experiments/[id] - Update experiment
POST /api/experiments/[id] - Record metrics

Dashboard

GET /api/dashboard - Get aggregated stats and insights

Reports

GET /api/reports - Get all reports

Integrations

GET /api/integrations - List integrations
POST /api/integrations - Configure integration

Environment Variables

Variable	Required	Description
`AI_PROVIDER`	No	AI provider to use: `anthropic` (default), `openai`, `google`, or `custom`
`ANTHROPIC_API_KEY`	Conditional	Anthropic API key (required if `AI_PROVIDER=anthropic`)
`OPENAI_API_KEY`	Conditional	OpenAI API key (required if `AI_PROVIDER=openai`)
`OPENAI_MODEL`	No	OpenAI model to use (default: `gpt-4`)
`GOOGLE_API_KEY`	Conditional	Google API key (required if `AI_PROVIDER=google`)
`DATABASE_URL`	No	SQLite database path (default: `file:./dev.db`)
`GITHUB_TOKEN`	No	GitHub PAT for automated repo creation
`GITHUB_USERNAME`	No	GitHub username for publishing prototypes

How It Works: The Idea-to-Validation Pipeline

Accelos directs Claude (via your API key) through a structured workflow:

Idea Submission - User submits idea via dashboard (Accelos stores it locally)
Orchestration - Accelos directs the Orchestrator to begin validation workflow
Market Research - Accelos directs Claude (Research role) to analyze market, competitors, trends, opportunities, risks
Strategic Planning - Accelos directs Claude (Strategy role) to propose pivots, experiments, and refined hypotheses based on research
Prototype Building - Accelos directs Claude (Builder role) to create working code, then uses your GitHub credentials to publish (optional)
Experimentation - User designs and runs experiments to validate hypotheses (tracked in Accelos)
Analysis - Accelos directs Claude (Analyst role) to review results and recommend next steps
Iteration - Cycle repeats with refined idea and new experiments
Scoring - Viability score updates as more data is gathered and stored locally

All execution logs are stored in Accelos, giving you a complete audit trail of how Claude was directed.

User-Credential Model

Accelos does not provide AI services—you bring your own credentials.

Your API keys, your control: All API calls are made using credentials you provide in .env.local
No central backend: Accelos runs locally (or on your infrastructure) and makes direct calls to Claude and GitHub
Transparent cost: You see exactly what you're paying for—every agent run hits your Anthropic account
Complete audit trail: Every agent execution, input, and output is logged in your local database

When you run agents, Accelos:

Takes your idea from the database
Directs Claude (using your API key) through structured prompts
Stores the responses in your database
Publishes results to GitHub (if credentials provided)
Logs everything locally for audit and analysis

This is fundamentally different from SaaS platforms that host agents—you maintain full control over your data, costs, and API usage.

Supported AI Providers

Accelos is provider-agnostic and works with multiple AI services. Configure which provider to use via the AI_PROVIDER environment variable in your .env.local:

Anthropic Claude (Default)

AI_PROVIDER=anthropic
ANTHROPIC_API_KEY=your_api_key

Model: claude-sonnet-4-6 (can customize the model name)
Get API key
Great for: Code generation, detailed reasoning, tool use

OpenAI GPT

AI_PROVIDER=openai
OPENAI_API_KEY=your_api_key
OPENAI_MODEL=gpt-4        # optional, defaults to gpt-4

Get API key
Great for: Multi-modal (vision), large context windows

Google Gemini

AI_PROVIDER=google
GOOGLE_API_KEY=your_api_key

Model: gemini-pro (configurable)
Get API key
Great for: Fast inference, multimodal capabilities

Custom Provider

To add support for other AI services (Cohere, Mistral, etc.), extend the AIProvider interface in src/lib/ai-provider.ts and add your implementation.

Updating Environment Variables

Update your .env.local file to change providers:

# Switch to OpenAI
AI_PROVIDER=openai
OPENAI_API_KEY=sk-proj-xxxx

# Or stay with Anthropic (default)
AI_PROVIDER=anthropic
ANTHROPIC_API_KEY=sk-ant-xxxx

Restart the dev server after changing providers. The app validates your configuration on the first API call and shows clear error messages if credentials are missing.

Deployment

The application is built with Next.js and can be deployed to any Node.js-compatible platform:

Vercel (Recommended)

npm install -g vercel
vercel login
vercel

Docker

docker build -t accelos .
docker run -p 3000:3000 accelos

Self-Hosted

Deploy to any Node.js host (AWS, Digital Ocean, Heroku, etc.) with:

npm run build
npm start

Ensure environment variables are properly configured in your deployment platform.

Contributing

This project is actively developed. Please follow the existing code style and add tests for new features.

License

Proprietary - Accelos Startup Accelerator

Support

For issues, questions, or feedback, please open an issue in the project repository.

Name		Name	Last commit message	Last commit date
Latest commit History 6 Commits
.claude		.claude
frontend		frontend
prisma		prisma
public		public
scripts		scripts
src		src
.gitignore		.gitignore
AGENTS.md		AGENTS.md
CLAUDE.md		CLAUDE.md
README.md		README.md
dev.db		dev.db
eslint.config.mjs		eslint.config.mjs
next.config.ts		next.config.ts
package-lock.json		package-lock.json
package.json		package.json
postcss.config.mjs		postcss.config.mjs
prisma.config.ts		prisma.config.ts
tsconfig.json		tsconfig.json

Folders and files

Latest commit

History

Repository files navigation