openGlad

What is openGlad?

openGlad is a Model Context Protocol (MCP) server that acts as the ultimate friction engine for startups. It provides AI agents (Claude, Cursor, Windsurf, Le Chat, etc.) with specialized tools to enforce loss-prevention before you write a single line of code:

• 🛑 Loss-Prevention Pipeline — Runs behavioral pattern scans, 3-scenario failure predictions, and locks building until monetization is confirmed.

• 🔍 Multi-Source Market Intelligence — Aggregates real-time data from Reddit (11+ subreddits), Hacker News, GitHub, and Polymarket prediction markets to detect overcrowding and entry risks.

• ⚔️ Comparative Friction Analysis — Runs parallel market intelligence on 2-3 ideas simultaneously and returns a ranked verdict on which one (if any) is worth pursuing.

• 📊 Startup Diagnostics — Evaluates execution stability, revenue health, burnout risk, and distribution discipline.

• 🩺 Clinical Triage — Objective, data-driven assessments with zero motivational fluff.

Think of it as an anti-delusion engine for your startup — designed to tell you 'no' before you waste months building the wrong thing.

Architecture

┌──────────────┐         ┌───────────────────────────────┐
│   AI Client  │  MCP    │   openGlad Worker             │
│  (Claude,    │◄──────►│   (Cloudflare Edge)           │
│   Cursor,    │         │      Version 5.0              │
│   Windsurf)  │         └─────────────┬─────────────────┘
└──────────────┘                       │ Parallel fetch (cached 1hr)
                          ┌────────────┼────────────┐
                   ┌──────▼──────┐ ┌──▼────┐ ┌─────▼──────┐ ┌──────▼──────┐
                   │   Reddit    │ │  HN   │ │   GitHub   │ │ Polymarket  │
                   │ 11+ subs    │ │Algolia│ │ Public API │ │  Gamma API  │
                   │ + topic exp.│ │ free  │ │  no key    │ │   free      │
                   └─────────────┘ └───────┘ └────────────┘ └─────────────┘

Tech Stack:

• Runtime: Cloudflare Workers (edge-deployed, globally distributed)

• Protocol: MCP (Model Context Protocol) via Streamable HTTP

• Market Data: Reddit + Hacker News (Algolia) + GitHub + Polymarket (all free, no API keys)

• Language: TypeScript (Modular Architecture)

Tools

🚧 Friction Engine (Loss Prevention)

🔍 Market Intelligence (Multi-Source)

Data Sources:

Reddit subreddits (base): r/Startup_Ideas · r/Business_Ideas · r/SaaS · r/SideProject · r/EntrepreneurRideAlong · r/IndieHackers · r/Futurology · r/Technology · r/AINewsAndTrends · r/Startups · r/Entrepreneur

Dynamic expansion adds topic-specific subreddits (e.g. r/MachineLearning for AI queries, r/CryptoCurrency for crypto, r/fintech for finance).

🩺 Startup Diagnostics

💬 MCP Prompts

📖 MCP Resources

Quickstart

Connect to the hosted server

The MCP server is deployed and ready to use:

https://openglad.tuguberk.dev/mcp

Claude Desktop / Cursor / Windsurf / Any MCP Client

Add to your MCP client configuration:

{
  "mcpServers": {
    "openGlad": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://openglad.tuguberk.dev/mcp"]
    }
  }
}

MCP Inspector (for testing)

npx @modelcontextprotocol/inspector@latest
# Enter URL: https://openglad.tuguberk.dev/mcp

Example Prompts

Once connected, try these with your AI client:

"Run the bet on my startup idea: an AI-powered tool that generates investor pitch decks from a one-page brief"

"Compare these two ideas for me: (1) AI accounting SaaS for freelancers, (2) no-code internal tools builder"

"Run a full health diagnostic on my startup with these metrics: MRR $12k, churn 8%, 3 developers, shipping weekly"

"Is the micro-SaaS market oversaturated? Check trends across Reddit, HN, and GitHub."

Deployment

Prerequisites

• Node.js 18+

• Cloudflare account

Deploy your own

# Clone and install
git clone https://github.com/tugberkakbulut/openGlad.git
cd openGlad
npm install

# Local development
npm run dev

# Deploy to Cloudflare
npx wrangler deploy

No API keys required — openGlad fetches all market data via free public APIs. Results are cached at the edge for 1 hour per query.

Project Structure

openGlad/
├── src/
│   ├── config/
│   │   └── constants.ts       # Subreddits + dynamic topic expansion map
│   ├── prompts/
│   │   └── index.ts           # LLM system prompts for all tools
│   ├── services/
│   │   ├── aggregator.ts      # Multi-source fetcher + evidence envelope wrapper
│   │   ├── reddit.ts          # Reddit search + engagement ranking + dedup + retry
│   │   ├── hackernews.ts      # HN Algolia API integration
│   │   ├── polymarket.ts      # Polymarket Gamma API integration
│   │   └── github.ts          # GitHub public search API integration
│   ├── tools/
│   │   ├── friction.ts        # Friction engine tools (run_the_bet, compare_ideas, etc.)
│   │   └── diagnostics.ts     # Diagnostic tools (execution, revenue, burnout, distribution)
│   ├── utils/
│   │   ├── dedupe.ts          # Jaccard N-gram deduplication + per-author caps + engagement scoring
│   │   └── helpers.ts         # Evidence envelope response builder
│   └── index.ts               # Server entry point, prompts, resources & tool registration
├── wrangler.jsonc              # Cloudflare Worker configuration
├── package.json
└── tsconfig.json

How It Works

Friction Engine Flow (Loss-Prevention)

1. User asks → "I want to build an AI resume builder"

2. AI client → Calls run_the_bet or analyze_startup

3. openGlad Worker → Fetches from 4 sources in parallel: Reddit (11+ subreddits), HackerNews, GitHub, Polymarket (all cached 1hr at edge)

4. Deduplication & Ranking → Jaccard similarity removes cross-source duplicates; per-author cap (max 3) prevents single-voice dominance; engagement scoring weights freshness + score + activity

5. Pattern Scan → Identifies behavioral risks (overbuilding, monetization avoidance)

6. Loss Simulation → Maps out 3 failure scenarios with quantified expected loss grounded in real market signals

7. Revenue Gate → Locks building until monetization is proven

8. User receives → A brutal reality check: blind spots, failure modes, and whether they're allowed to build

compare_ideas Flow

1. User provides → 2-3 startup idea descriptions

2. Parallel fetch → Market context fetched for all ideas simultaneously

3. Comparative analysis → Each idea gets a compressed friction block (pattern risk, market signal, expected loss, gate status)

4. Ranked verdict → Single recommendation on which idea (if any) to pursue

Built With

• Cloudflare Workers — Serverless edge computing

• Model Context Protocol — Standard protocol for AI tool integration

• Cloudflare Agents SDK — MCP server framework

• Reddit Public JSON API — Community market intelligence

• Hacker News Algolia API — Developer community signals

• GitHub REST API — Open source adoption & competitor activity

• Polymarket Gamma API — Prediction market odds

Inspiration

Multi-source aggregation, Jaccard deduplication, engagement-based ranking, thin-source retry, and evidence envelope patterns are inspired by mvanhorn/last30days-skill (MIT).

License

MIT