# CEO Strategy Prover MCP

> CEO Strategy Prover forces any strategic idea through five CEO-level checks. It validates whether a market vision is built on structural moats, uses real competitive precedents, defines metrics, and understands its true Total Addressable Market (TAM). Stop treating strategy like a slide deck—this MCP tests if your plan can actually survive the boardroom.

## Overview
- **Category:** strategy
- **Price:** Free
- **Tags:** ceo, strategy, moat, platform, competitive-intelligence, execution, tam

## Description

When you're building something big, most people fall for the easy wins: 'we just need better features,' or 'the market is huge.' The CEO Strategy Prover fixes that. It forces you to look past product roadmaps and think like a company built for decades. Instead of generating vague vision statements, this MCP makes you prove your case across five critical business axes. You'll ground every move in specific industry precedents—naming the companies that succeeded or failed before you did. We check if your moat is structural (data flywheel, network effects) or just 'better product.' It also forces you to define metrics and kill criteria upfront, so there are no surprises when things get tough. Connecting this MCP through Vinkius gives your agent immediate access to deep strategic validation that simple prompt engineering can't touch.

## Tools

### validate_ceo_strategy
This tool reviews any proposed strategy against five dimensions—ecosystem thinking, competitive history, structural moats, metrics, and market size—to issue a pass/fail verdict.

## Prompt Examples

**Prompt:** 
```
Add a feature to improve conversion. We are better than competitors. The market is large. Others have tried similar approaches. Execute the strategy and dominate the space.
```

**Response:** 
```
SMALL_THINKING — Five fatal gaps: feature-level thinking, vague precedents, weak moat, vision-without-plan, market-blind language.
```

**Prompt:** 
```
Platform: become data infrastructure for healthcare — third-party apps build on APIs, each integration increases switching costs. Precedent: Veeva built vertical CRM for pharma, captured 80% share in 5 years. Moat: network effects + data flywheel (2M patient records). Execution: North Star weekly active integrations, 90-day 50 providers, 6-month $500K ARR, kill if <20 at month 6. Market: $47B health IT (Gartner, 22% CAGR), AWS will react in 18mo — our moat is vertical specialization. HIPAA compliance is our barrier. API-first adoption hit 40% in 2025.
```

**Response:** 
```
STRATEGY_PROVEN — CEO-level strategy validated. All five axes pass. Execute.
```

**Prompt:** 
```
We have a strong product but our organizational structure has 6 management layers for 80 employees. Decision cycles take 3 weeks. Should we restructure?
```

**Response:** 
```
Organizational friction detected. 6 layers for 80 people is bureaucratic overhead. Flatten to 3 layers maximum. Empower teams with decision authority. Speed is a strategic weapon.
```

## Capabilities

### Validate Ecosystem Thinking
It forces you to define the platform or infrastructure your company will build, identifying who depends on it and how that creates systemic gravity.

### Ground Strategy in Precedents
The MCP requires citing specific competitive examples (company, move, timeline) instead of relying on vague claims about 'the industry.'

### Identify Structural Moats
You define the core defensibility—like network effects or switching costs—that keeps competitors from easily replicating your advantage.

### Define Metric-Driven Execution
It structures execution plans by mandating a North Star metric, clear milestones, and defined kill criteria for the project.

### Assess Market Reality and Timing
You validate market assumptions using quantified TAM figures, predicting how major competitors will respond to your entry point.

## Use Cases

### Launching a new vertical SaaS product
A founder proposes building an HR tool. The agent runs the strategy through validate_ceo_strategy, which immediately flags 'Small Thinking,' forcing the team to rethink the offering as an infrastructure layer for all HR systems in that niche.

### Entering a saturated market
A sales VP wants to challenge an incumbent. They use the MCP to build a competitive timeline, citing historical precedents of industry shifts (like streaming vs. DVDs) to show exactly where the competitor's weakness lies.

### Securing Series B funding
A CEO prepares for investor due diligence. Using validate_ceo_strategy, they map out their financial moat and execution roadmap, ensuring every milestone has a defined budget owner and kill date.

## Benefits

- You stop writing slide decks. Instead, you get a structured validation that forces teams to think in terms of platforms and ecosystems, not just standalone features.
- It makes vague claims concrete. You must cite specific company precedents, moving beyond 'others have tried' to actual historical proof points.
- Your team defines clear exit criteria. The tool demands North Star metrics and kill criteria for every initiative, eliminating scope creep before it starts.
- You identify real defensibility. Instead of saying 'better product,' you define structural moats like data flywheels or network effects that are hard to replicate.
- The MCP validates market assumptions by requiring specific TAM sources and modeling how top competitors will actually react.

## How It Works

The bottom line is you get an immediate, objective assessment of whether your strategy has enough rigor to move past the pitch deck stage and into execution.

1. Input your proposed strategy into the MCP by providing details across all five strategic axes.
2. The tool processes this input against established Big Tech benchmarks, checking for structural weaknesses and missing data points.
3. You receive a clear verdict: 'STRATEGY_PROVEN' or a specific failure code (e.g., SMALL_THINKING), detailing exactly which axis needs work.

## Frequently Asked Questions

**Why does it reject 'better product' as a moat?**
'Better product' is not a moat — competitors hire engineers too. Structural moats compound: network effects (each user increases value), data flywheels (proprietary data improves with scale), switching costs (leaving is painful), ecosystem gravity (complementary products create lock-in).

**Why does it demand competitive precedents?**
Strategy without precedent analysis is guessing with confidence. Name the company, the move, the timeline, the outcome. 'Netflix pivoted to streaming in 2007 when broadband hit 50%' — that is intelligence. 'Others have tried' tells you nothing.

**What is EXECUTION_GAP?**
Vision without execution. Define: North Star metric, 90-day milestones, team structure, budget allocation, and kill criteria. 'Execute the strategy' is not a plan — it is a wish.

**When running `validate_ceo_strategy`, what specific details should I include regarding 'Platform Strategy'?**
You must define the infrastructure layer, not just a product feature. Think about building an ecosystem that others rely on; this is key to creating lasting gravity.

**When does the tool trigger a failure state like `SMALL_THINKING` using `validate_ceo_strategy`?**
It triggers when your strategy focuses only on adding features or improving one product. A true strategy must describe an entire, larger platform or ecosystem.

**For `validate_ceo_strategy`, how must I source and validate the Total Addressable Market (TAM)?**
Always provide a specific source for your TAM figure. The tool validates the structure of the market claim, but you own the accuracy of the underlying data.

**Are there any rate limits or performance considerations when calling `validate_ceo_strategy`?**
Vinkius manages general usage limits across all MCPs. Be aware that highly complex inputs, especially those detailing multiple competitive precedents, take more time to process.

**What is the best way to use `validate_ceo_strategy` across different AI clients?**
Since it's an MCP, you connect your preferred client (Claude, Cursor, etc.) once. Your agent then uses this MCP directly, regardless of which app interface you're using.