founder-intelligence
# Founder Intelligence — ChatGPT Desktop + local Node.js MCP
**Version:** 1.1.1 (documentation target; verify plugin metadata matches the published release)
**Platform:** ChatGPT Desktop with local execution (where supported) / Codex
**Runtime:** Node.js **20+**
**Third-party npm dependencies:** none
**MCP transport:** STDIO; local process, no listening port, no authentication token, no public tunnel
**Developer:** International Business Sources
**Language:** instructions in English; ChatGPT can answer in French, English or other requested languages.
> **Scope:** This is an independent ChatGPT adaptation of the _ideas and documented features_ of [Jakeschincariol/founder-skill](https://github.com/Jakeschincariol/founder-skill), **not** an exact copy or a line-for-line translation of the original skills. Original contributors retain their rights. See `LICENSE`. The simulated buyer panel is hypothetical, not empirical market research.
## 1. What is included?
- **12 skills:** `founder-orchestrator` plus board, competitors, consumer, pricing, offer, CFO, marketing, brand, operations, launch, and plan.
- **One local MCP server:** `mcp/server.mjs`, which runs on your machine using Node.js and exposes five read-only MCP tools.
- **Four JavaScript modules:** `scripts/unit_economics.mjs`, `scripts/panel.mjs`, `scripts/van_westendorp.mjs`, `scripts/compile.mjs`.
- **One personal-marketplace installer:** `scripts/install-local.mjs`. This copies the plugin into your local plugin directory and adds/updates its entry in the personal marketplace.
- **10 automated tests**, including real MCP STDIO initialize, list and call round trips.
### MCP tools
| MCP tool | Uses | Input |
| -------------------------- | ---------------------------------------------------------------- | --------------------------------------------------- |
| `founder_unit_economics` | Unit margin, break-even, 12-month cash / forecast, sensitivities | `financials` object |
| `founder_panel_initialize` | Reproducible **synthetic** buyer profiles | `customer`, `pitch`, optional `n`, `seed` |
| `founder_panel_tally` | Counts answers supplied to the tool; **never fabricates votes** | `answers` array |
| `founder_van_westendorp` | Price sensitivity intersections | `responses`, optional `tested_price`, `data_origin` |
| `founder_plan_evaluate` | Consolidated, modeled financial checklist | `finance`, `panel`, optional `min_buy_rate` |
**Important:** the fifth MCP tool uses the fourth script (`compile.mjs`) for **evaluation only**. It does not write a business-plan file. The CLI script can still compile Markdown files from a local project directory if you launch it manually.
## 2. Prerequisites
1. Install **ChatGPT Desktop** from an official OpenAI distribution and use a mode that supports **local computer execution**. Availability varies by application and account.
2. Install [Node.js 20+](https://nodejs.org/) and [Git](https://git-scm.com/downloads). No `npm install` is required.
3. Clone this GitHub repository (commands below). Do not download the source as an extracted ZIP: the Git workflow makes updates easier.
4. Open **Terminal** (macOS/Linux) or **PowerShell** (Windows).
Check the runtime:
```sh
node --version
npm --version
```
`node --version` must print `v20` or higher. On macOS, the Desktop app may need to be restarted after installing Node.js, so the new executable is available in its environment.
## 3. Installation depuis GitHub — macOS / Linux
> **Official source repository:** [mohamed-ibn-elazzouzi/founder-intelligence](https://github.com/mohamed-ibn-elazzouzi/founder-intelligence). These commands will work after the repository has been published with the project files at its root.
**A. Clone the public repository:**
```sh
git clone https://github.com/mohamed-ibn-elazzouzi/founder-intelligence.git
cd founder-intelligence
```
Check that the repository root contains the expected files:
```sh
ls plugin.json mcp.json mcp/server.mjs scripts/install-local.mjs
```
**B. Check the runtime and execute the tests:**
```sh
node --version
npm test
```
Node.js 20+ is required. The tests must pass before installing. The project has no external npm dependencies, so there is no `npm install` step.
**C. Install the plugin in the personal local marketplace:**
```sh
node scripts/install-local.mjs
```
The installer copies the current checkout into:
- `~/.codex/plugins/founder-intelligence/` — installed plugin and MCP server
- `~/.agents/plugins/marketplace.json` — personal marketplace entry
Other entries in `plugins[]` are preserved; an existing marketplace JSON file is backed up as `marketplace.json.bak`. The install does not send source files to the cloud.
**D. Enable the plugin:** restart ChatGPT Desktop and, **if your build supports local plugin marketplaces**, open Plugins Directory, select the personal/local marketplace (`Personal Local Plugins` when created by the installer), and install/enable **Founder Intelligence**. Start a new local session and use the examples in sections 6–10.
**Note:** the installer is not a guarantee that a specific ChatGPT Desktop release exposes local plugin or STDIO MCP support. If those features are unavailable, use the standalone Codex CLI MCP setup in section 5.
## 4. Installation depuis GitHub — Windows (PowerShell)
**A. Clone the repository:**
```powershell
git clone https://github.com/mohamed-ibn-elazzouzi/founder-intelligence.git
cd .\founder-intelligence
```
**B. Run tests and install:**
```powershell
node --version
npm test
node .\scripts\install-local.mjs
```
The installer creates `%USERPROFILE%\.codex\plugins\founder-intelligence` and updates `%USERPROFILE%\.agents\plugins\marketplace.json`. Restart ChatGPT Desktop and enable the personal/local plugin if that feature is available in your Windows installation. For a standalone MCP connection, follow section 5 instead.
## 5. Alternative: register MCP independently (without installing the skills)
You can connect the server directly first, to confirm that the MCP integration works.
**ChatGPT Desktop with local MCP support** (only if this integration/menu exists in your particular build):
1. Open **Settings → MCP servers → Add server**.
2. Name: `founder-intelligence`.
3. Transport: **STDIO**.
4. Command: absolute path to the Node.js executable, e.g. `/opt/homebrew/bin/node` (Mac Apple Silicon, when installed there); use `which node` or `where.exe node` to locate the correct executable. A simple `node` may also work if the desktop environment includes Node in `PATH`.
5. Arguments: absolute path to `mcp/server.mjs` in the extracted folder, e.g. `/Users/YOUR_NAME/projects/founder-intelligence/mcp/server.mjs` (the path to your **cloned repository**, not a ZIP).
6. Save, then **Restart** the MCP host and verify the tool list.
**Codex CLI alternative:**
```sh
codex mcp add founder-intelligence -- node /ABSOLUTE/PATH/TO/founder-intelligence/mcp/server.mjs
codex mcp list
```
Use absolute paths when configuring a standalone server. Registering MCP this way makes the five tools available, but **does not automatically register the 12 skill workflows**; install the plugin to get both. Avoid registering duplicate server instances with the same name if you also install the bundled MCP plugin.
You can configure the server manually in `~/.codex/config.toml`:
```toml
[mcp_servers.founder-intelligence]
command = "node"
args = ["/ABSOLUTE/PATH/TO/founder-intelligence/mcp/server.mjs"]
```
Use a Windows full path on Windows; TOML literal strings or escaped backslashes are required when appropriate. The bundled plugin already includes the equivalent portable configuration in `mcp.json`:
```json
{
"$schema": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
"mcpServers": {
"founder-intelligence": {
"type": "stdio",
"command": "node",
"args": ["${PLUGIN_ROOT}/mcp/server.mjs"],
"cwd": "${PLUGIN_ROOT}"
}
}
}
```
`${PLUGIN_ROOT}` is resolved by a plugin-aware host. Do **not** put `${PLUGIN_ROOT}` into a standalone `config.toml` and assume it will be expanded.
## 6. Using Founder Intelligence in ChatGPT Work
1. Open **ChatGPT Desktop** and select **Work** in an environment that supports the installed local plugin.
2. Enable **Founder Intelligence**. For a specific workflow, say **“Use the `founder-cfo` skill from Founder Intelligence…”**. A Claude-style `/founder-cfo` slash command is **not guaranteed to work in ChatGPT**.
3. Include the business model, target customer, territory, stage, constraints, and which figures are known versus assumptions.
4. When you need a JavaScript calculation, explicitly request the relevant MCP tool and ask the assistant to confirm whether it actually received a response. Merely mentioning the tool or calculating the same number is not proof that Node.js executed it.
5. Request sources for external market claims. Treat synthetic buyer responses and hypothetical prices as **illustrations, not research evidence**.
**Quick connectivity check — paste into Work:**
> Use Founder Intelligence. List the five registered MCP tools. Then actually call `founder_unit_economics` using the full illustrative `financials` object shown in section 9. Tell me whether the tool call succeeded, and show the returned unit contribution and break-even. If you cannot access the tool, say so and do not simulate the response.
**Execution boundary:** the local MCP server performs deterministic arithmetic and synthetic persona generation; the skills themselves are instructions. Work does not necessarily expose access to your Mac's Node.js process in every account or session. Local MCP connectivity must be confirmed through a real call.
## 7. Independent demonstration scenario — VéloService Pro
All tutorials below use the **same fictional but operationally plausible company**, not a project belonging to the maintainer or a real client.
**VéloService Pro** is a proposed mobile bicycle-maintenance service for companies operating employee or delivery bicycle fleets in **Lyon, France**. A technician visits customers' premises for planned servicing and minor repairs. The commercial buyer may be a fleet manager, facilities manager, operations director, or HR manager. A "unit" in the simplified finance example means **one billed maintenance intervention**, not a monthly subscription.
**Illustrative assumptions — not verified market facts:**
| Item | Illustrative value | Why it matters |
| ----------------------------------------------- | ---------------------------------------------------------: | ------------------------------------------------------------- |
| Selling price per intervention | EUR 150 | Revenue per billable job |
| Direct parts/travel/labor cost per intervention | EUR 55 | Variable cost, avoid double-counting payroll |
| Monthly fixed operating costs | EUR 3,600 | Insurance, vehicle, overhead, non-variable salary allocations |
| One-time setup cost | EUR 6,000 | Equipment, setup and launch |
| Working days per month | 20 | Planning assumption |
| Interventions per day at full utilization | 3 | Capacity assumption to validate in field tests |
| Initial geography | Greater Lyon | Delivery radius constraint |
| Revenue model | Fee per intervention; annual fleet contracts to test later | Avoid pretending repeat billing is already proven |
**Validation goal:** determine whether the company can win sufficient recurring B2B work at a contribution margin that supports technician utilization and routing costs. Research actual competitors and buyers separately; nothing in this example asserts that the market pays EUR 150.
### The 12 skills at a glance
| Skill | Typical user need | Deliverable |
| ---------------------- | ----------------------- | ------------------------------------------------------- |
| `founder-orchestrator` | End-to-end assessment | Integrated decision and conflicting assumptions |
| `founder-board` | Challenge a concept | Strategic critique, GO / CONDITIONAL GO / NO-GO |
| `founder-competitors` | Understand alternatives | Competitor matrix with sourced evidence |
| `founder-consumer` | Explore buyer reactions | Synthetic personas, objections and interview hypotheses |
| `founder-pricing` | Test how to charge | Price architecture and survey-analysis guidance |
| `founder-offer` | Package services | Productized packages, scope and exclusions |
| `founder-cfo` | Quantify viability | Contribution, break-even, capacity and scenarios |
| `founder-marketing` | Acquire leads | Segmented channels, funnel, campaigns and experiments |
| `founder-brand` | Explain differentiation | Brand positioning and messaging |
| `founder-ops` | Deliver reliably | Workflow, staffing, SLA and quality controls |
| `founder-launch` | Get to market | Milestones, success metrics and stop/go gates |
| `founder-plan` | Consolidate the case | Business plan and unresolved evidence |
## 8. Realistic prompts for **every skill**
Each prompt can be copied into a separate ChatGPT Work conversation with Founder Intelligence enabled, or executed sequentially in one project session. The skills need not be run in this order if only one question matters.
### 8.1 `founder-board` — challenge the decision to launch
**When:** before spending money on inventory, staff or sales. **Expected:** three distinct perspectives, downside case, key assumptions and decision gates.
> Use the `founder-board` skill for **VéloService Pro**, a planned mobile maintenance service for corporate bicycle fleets in Lyon. Evaluate the attractiveness of servicing corporate fleets, whether on-site convenience is defensible, and the operational risks of a technician business. Separate the proposition's appeal from proven willingness to buy. Give me the five strongest reasons **not** to launch, the five most decisive validation questions, and a CONDITIONAL GO/NO-GO decision with explicit criteria.
### 8.2 `founder-competitors` — map the actual competitive set
**When:** identifying differentiation. **Expected:** direct providers, bicycle shops, in-house mechanics and other substitutes, with evidence.
> Use `founder-competitors` to investigate mobile bicycle maintenance services and fleet-servicing alternatives in Greater Lyon. Look for verified company names, geography, service options, target segments, published prices (only if visible) and customer proof. Include indirect substitutes such as a fleet operator's own mechanic. Cite every externally verified claim; record unknown prices as "not published". Summarize the gaps VéloService Pro could test rather than assuming competitors are weak.
### 8.3 `founder-consumer` — explore buyer objections **synthetically**
**When:** preparing interview scripts, not establishing market size. **Expected:** reproducible persona cards and hypotheses for real interviews.
> Use `founder-consumer` to explore prospective buyers of VéloService Pro. **Actually call** `founder_panel_initialize` with `customer={"segment":"Corporate bicycle-fleet purchasers in Lyon","segments":["Fleet manager","Operations director","Facilities manager","HR manager","Procurement manager"],"objections":["price","downtime","supplier reliability","fleet too small","existing maintenance contract"]}`, `pitch="On-site scheduled bicycle maintenance for employer and delivery fleets in Greater Lyon, billed per intervention, with optional fleet service agreement"`, `n=30`, and `seed=42`. Summarize segment/objection patterns. For each buyer role, draft three questions for a real interview. Do not invent interviews, purchase votes or survey percentages.
**Important:** the tool generates cards, not real survey answers. Only use `founder_panel_tally` **after** you have explicitly provided answer records; simulated `yes` counts are not evidence of conversion.
### 8.4 `founder-pricing` — test charge structure, not imaginary survey results
**When:** choosing between per-intervention fees and fleet contracts. **Expected:** price model, testable hypotheses, pricing-survey protocol.
> Use `founder-pricing` for VéloService Pro. Compare (1) EUR-per-intervention billing, (2) prepaid maintenance bundles for fleets, and (3) a contract with a fixed monthly retainer plus per-visit charges. Explain benefits, risks, who would prefer each and how to avoid unprofitable travel. Create a four-question Van Westendorp survey to administer to **real** fleet buyers. If I provide responses, call `founder_van_westendorp`; until then, mark any illustrative thresholds as synthetic and do not claim an optimal market price.
### 8.5 `founder-offer` — turn a service into three sellable packages
**When:** translating a service into procurement-friendly deliverables. **Expected:** offer cards, acceptance rules, service boundaries.
> Use `founder-offer` to define three commercial packages for VéloService Pro: **Essential** (preventive inspection), **Fleet Care** (scheduled service with intervention reports) and **Priority** (service-level commitment subject to technician availability). Specify what is included, minimum fleet size, service area, excluded repairs, parts approval, visit cancellation, outputs, customer prerequisites and upsell triggers. Do not invent contractual response-time guarantees or assume that the company can deliver 24/7.
### 8.6 `founder-cfo` — calculate unit economics with the real MCP tool
**When:** validating capacity and break-even. **Expected:** deterministic calculations and sensitivity cases.
> Use `founder-cfo`. **Call `founder_unit_economics`**, not mental arithmetic, with the exact `financials` object in section 9A: price EUR 150, variable cost EUR 55, monthly fixed costs EUR 3,600, startup costs EUR 6,000, 20 days/month and 3 interventions/day. Show the returned contribution, full-capacity operating profit, break-even interventions, 12-month cash trajectory and price/volume sensitivities. Identify labor, travel-time, VAT and customer acquisition elements missing from this simplified unit model. If the MCP tool is unavailable, state that.
**Model sanity check:** contribution EUR 95 per intervention; theoretical break-even **38 interventions/month**; full-capacity operating profit **EUR 2,100/month** at 60 interventions. These are model outputs under stated assumptions, not business forecasts.
### 8.7 `founder-marketing` — generate qualified sales meetings
**When:** finding first fleets. **Expected:** ICP, outreach offers, channel experiments and a measurable funnel.
> Use `founder-marketing` to build a **90-day acquisition plan** for VéloService Pro in Greater Lyon. Prioritize organizations with visible corporate bicycle fleets, delivery operations or employer mobility programs. Segment fleet managers, facilities and procurement. Propose public-source prospecting, partnerships with bike suppliers, on-site demonstration days and LinkedIn outreach. For each channel specify outreach volume assumptions, meeting-rate hypothesis, test budget, KPI, attribution and stop criterion. Do not describe invented leads as actual prospects.
### 8.8 `founder-brand` — clarify the buyer promise
**When:** building a distinct commercial identity. **Expected:** positioning, claims, tagline alternatives and proof requirements.
> Use `founder-brand` for VéloService Pro. Develop positioning for an operational B2B purchaser: fewer bicycle breakdowns, simpler fleet scheduling and transparent service reports. Suggest three messaging territories, a one-sentence positioning statement, two tagline options and a homepage hero. Make a table of claims we may communicate now versus claims (such as "40% less downtime") that require measurement. Avoid greenwashing and unsupported certifications.
### 8.9 `founder-ops` — see if the promises are deliverable
**When:** designing how work will actually happen. **Expected:** service blueprint, resources, controls and risks.
> Use `founder-ops` to design the operating model of VéloService Pro. Cover lead intake, eligibility screening, fleet inventory, appointment booking, route planning, repair authorization, parts inventory, intervention checklist, safety verification, customer sign-off and invoicing. Assume one mobile technician initially. Model realistic scheduling buffers, daily capacity constraints, escalation for complex repairs, insurance/safety considerations and an operational KPI dashboard. Identify which cost inputs must be revised in `founder-cfo` after this analysis.
### 8.10 `founder-launch` — design a controlled 12-week pilot
**When:** executing early market validation. **Expected:** dated milestones or week-based phases, owners, KPIs, stopping rules.
> Use `founder-launch` to plan VéloService Pro's first **12 weeks** in Lyon. Weeks 1–2: buyer interviews and competitor verification; 3–4: service blueprint and insurance/parts checks; 5–8: paid pilot with a small number of real corporate fleets; 9–10: cost and retention analysis; 11–12: GO/NO-GO. For each phase provide a role owner, milestone, budget hypothesis, leading metric and explicit stop/go gate. Distinguish planned pilot targets from accomplished sales.
### 8.11 `founder-plan` — assemble a decision-ready business plan
**When:** consolidating validated findings and assumptions. **Expected:** coherent plan, risk register and unresolved evidence.
> Use `founder-plan` to prepare a decision-ready business plan for VéloService Pro using the earlier analyses. Include an executive summary, target market and competitors with citations, offer and go-to-market strategy, staffing and route capacity, the actual `founder_unit_economics` output, a 12-month scenario table, risks, experiments and investment gates. If finance and panel output objects exist, **actually call** `founder_plan_evaluate` and label its verdict as model-only. If either input is missing, mark the checklist incomplete instead of inventing results.
### 8.12 `founder-orchestrator` — run all eleven skills coherently
**When:** a full idea-to-launch assessment is needed. **Expected:** integrated assessment and contradiction resolution.
> Use `founder-orchestrator` to evaluate **VéloService Pro**, a proposed mobile maintenance company for business bicycle fleets in Lyon. Coordinate **all 11 domain skills**: board, competitors, consumer, pricing, offer, CFO, marketing, brand, ops, launch and plan. Use documented assumptions from section 7, conduct external research with citations where tools permit, create only explicitly labeled synthetic personas, and call the local MCP tools for calculations only when connected. Reconcile promised SLAs with one-technician capacity, price with variable costs and acquisition ambitions with the operating budget. Deliver a CONDITIONAL GO/NO-GO memo plus a validation backlog; never fabricate market evidence or MCP calls.
**Workflow quality rule:** when operations invalidate the capacity assumption, revisit CFO calculations before completing the plan. A convincing narrative is not a substitute for reconciled figures.
## 9. Exact MCP tool calls for the demonstration
The JSON examples below are **tool argument objects**, not configuration snippets. They match the expected input structure of the bundled local MCP server. You can paste the JSON into your Work request and ask ChatGPT to call the corresponding tool. A tool call can be confirmed only by observing its actual result in a connected session.
### 9A. `founder_unit_economics` — financial example
```json
{
"financials": {
"currency": "EUR",
"price": 150,
"variable_cost": 55,
"fixed_costs_monthly": 3600,
"additional_monthly_costs": 0,
"startup_costs": 6000,
"operating_days_per_month": 20,
"planned_units_per_day": 3,
"monthly_ramp": [0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1, 1, 1, 1]
}
}
```
Ask: _“Call `founder_unit_economics` with these arguments, then show the response and test how profitability changes if volume drops by 20%.”_
The tool computes a simplified **per-intervention** model. It does not automatically account for tax, working capital, route optimization, fleet retention, debt or wage accounting. Do not model a recurring contract as a one-off intervention without adjusting the assumptions.
### 9B. `founder_panel_initialize` — synthetic buyer profiles
```json
{
"customer": {
"segment": "Corporate bicycle-fleet purchasers in Lyon",
"segments": [
"Fleet manager",
"Operations director",
"Facilities manager",
"HR manager",
"Procurement manager"
],
"objections": [
"price",
"downtime",
"supplier reliability",
"fleet too small",
"existing maintenance contract"
]
},
"pitch": "On-site scheduled maintenance for business bicycle fleets in Greater Lyon, billed per intervention, with optional fleet service agreement",
"n": 30,
"seed": 42
}
```
Ask: _“Call `founder_panel_initialize` with this structured customer object and list the distribution of synthetic objections. Do not infer demand or buying intent.”_
The tool produces persona cards with synthetic segment, primary objection and price sensitivity. It does **not** conduct interviews or automatically produce votes.
### 9C. `founder_panel_tally` — responses explicitly supplied
```json
{
"answers": [
{
"id": "buyer-0001",
"buy": "yes",
"reason": "Avoid on-site fleet downtime"
},
{
"id": "buyer-0002",
"buy": "no",
"reason": "Existing maintenance contract"
},
{ "id": "buyer-0003", "buy": "undecided", "reason": "Need a paid pilot" }
]
}
```
These are **three illustrative, fabricated answers**, not votes automatically returned by `founder_panel_initialize`. Ask: _“Call `founder_panel_tally` on these hypothetical answers; return counts and mark the result synthetic, not actual conversion.”_
### 9D. `founder_van_westendorp` — sample price thresholds
```json
{
"responses": [
{ "too_cheap": 60, "cheap": 90, "expensive": 160, "too_expensive": 230 },
{ "too_cheap": 70, "cheap": 100, "expensive": 170, "too_expensive": 240 },
{ "too_cheap": 65, "cheap": 95, "expensive": 150, "too_expensive": 220 },
{ "too_cheap": 80, "cheap": 110, "expensive": 180, "too_expensive": 250 }
],
"tested_price": 150,
"data_origin": "synthetic"
}
```
Ask: _“Call `founder_van_westendorp`; display any intersection points and the small-sample warning. Do not claim EUR 150 is a validated optimal price.”_ A survey needs real, independently collected responses to support real market pricing; a small hypothetical dataset is only for testing the algorithm.
### 9E. `founder_plan_evaluate` — consolidate actual previous outputs
```json
{
"finance": {
"...": "REPLACE with the exact founder_unit_economics result object"
},
"panel": {
"...": "REPLACE with the exact founder_panel_tally result object"
},
"min_buy_rate": 0.25
}
```
The placeholder objects are **not runnable analysis inputs**. In a connected Work session, ask:
> Use the exact `finance` result returned by `founder_unit_economics` and the exact `panel` result returned by `founder_panel_tally` earlier in this session to call `founder_plan_evaluate` with `min_buy_rate=0.25`. Return the modeled assessment, explicitly noting that the supplied panel answers were hypothetical.
This tool evaluates existing model objects. It **does not** save a `.md` business plan to disk. The separate `scripts/compile.mjs` CLI can assemble local Markdown inputs when invoked manually.
## 10. Complete guided tutorial: from first idea to launch decision
Use a **single Work session** when possible to preserve assumptions and reuse actual tool outputs:
1. **Frame the hypothesis** with `founder-board`: what must be true for a mobile fleet-maintenance business to work?
2. **Check actual alternatives** with `founder-competitors`: cited Lyon-area providers and substitutes, not invented competitor ratings.
3. **Prepare discovery** with `founder-consumer`: synthetic objections, then interview 10–15 real buyers outside the plugin.
4. **Design the commercial package** with `founder-offer` and `founder-pricing`: scope, price hypothesis, travel conditions, payment terms.
5. **Reconcile delivery and economics** with `founder-ops` and `founder-cfo`: service duration, route capacity, contribution margin, break-even; rerun finance if inputs change.
6. **Plan demand generation** with `founder-brand` and `founder-marketing`: evidence-based messages, buyer lists, experiments and pipeline KPIs.
7. **Run a time-boxed pilot plan** with `founder-launch`: 12 weeks with gates and owner roles.
8. **Consolidate** with `founder-plan` and, when valid prior MCP outputs exist, `founder_plan_evaluate`.
9. **Request a final review** through `founder-orchestrator`: unresolved assumptions, major contradictions, decision and next evidence to collect.
**Copy-paste prompt for the complete walkthrough:**
> Use Founder Intelligence to evaluate **VéloService Pro**, a fictional mobile bicycle-fleet maintenance service in Lyon, France. Cover every skill: `founder-board`, `founder-competitors`, `founder-consumer`, `founder-pricing`, `founder-offer`, `founder-cfo`, `founder-marketing`, `founder-brand`, `founder-ops`, `founder-launch` and `founder-plan`, coordinated by `founder-orchestrator`. Model EUR 150 per visit, EUR 55 variable cost, EUR 3,600 monthly fixed costs, EUR 6,000 initial setup, 20 working days and a 3-visit/day capacity assumption. Ask for actual MCP tool calls where supported, cite any verified market facts, label all other inputs hypothetical, and provide a conditional GO/NO-GO with concrete validation experiments. Do not claim that simulated buyers were interviewed.
## 11. Troubleshooting
| Symptom | Check |
| ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ChatGPT says tools are unavailable | Use the **local** desktop/Codex session, not hosted Web-only chat; verify MCP server status and plugin installation |
| `node: command not found` / `ENOENT` | Install Node.js 20+; restart ChatGPT Desktop; configure the **absolute Node path** |
| MCP server exits on startup | Run `node mcp/server.mjs` directly and inspect **stderr**; STDIO servers normally wait for JSON-RPC messages |
| Server appears but tool calls fail | Run `npm test`; ensure financial inputs satisfy `references/number-schema.md` |
| Plugin does not appear | Check `~/.agents/plugins/marketplace.json`, verify its relative plugin path, restart Desktop, select the local marketplace |
| Duplicate tools | Remove the independently registered server if the plugin includes the same bundled MCP server |
| Browser ChatGPT cannot find local MCP | ChatGPT web does not read a local Codex configuration; use a supported local desktop client |
| Account blocks local MCP deployment | Personal local development may still work on supported clients; distributing _Desktop only_ plugins via OpenAI's directory requires approval/allowlisting |
**Security:** the server has no shell execution, `eval`, filesystem-write tool, HTTP listener or credentials. It only calculates on data passed in the MCP call. The optional _installer_ writes the plugin files and the personal marketplace JSON. Local computation does **not** mean the prompts and tool results you share in ChatGPT are never transmitted to OpenAI; review your application privacy settings and enterprise policies.
## 12. Update and uninstall
**Update from the GitHub repository:** use the folder where you originally ran `git clone`. Commit or stash your own local modifications before pulling.
```sh
cd /PATH/TO/founder-intelligence
git pull --ff-only
npm test
node scripts/install-local.mjs
```
Windows PowerShell uses the same commands (replace the `cd` path). The installer copies the updated checkout into the local plugin directory; restart ChatGPT Desktop and refresh or reinstall the plugin if requested. If your plugin is registered only as a standalone MCP server using the cloned path, `git pull --ff-only` plus a restart of the MCP host is sufficient.
**Pin a published release (recommended for reproducible deployments):** after cloning, run `git fetch --tags` and `git checkout v1.1.1` if the maintainer has published that tag. To switch back to the latest tracked branch, use `git switch main` (or the repository's actual default branch).
**Uninstall:** disable/remove the plugin in ChatGPT Desktop, delete `~/.codex/plugins/founder-intelligence`, and remove the `founder-intelligence` entry from `~/.agents/plugins/marketplace.json` while preserving other plugins. If you registered the server independently, run `codex mcp remove founder-intelligence` (where supported) or remove its entry from `~/.codex/config.toml`.
## 13. Documentation
- [OpenAI — Package your plugin](https://developers.openai.com/plugins/build/plugins)
- [OpenAI — Desktop-only local MCP](https://developers.openai.com/plugins/deploy/desktop-only)
- [OpenAI — Configure MCP in ChatGPT Desktop / Codex](https://learn.chatgpt.com/docs/extend/mcp)
- [Agent Plugins specification](https://agent-plugin.org/en/specification)
- [Original founder-skill project](https://github.com/Jakeschincariol/founder-skill)
## 14. Known limitations
- The 11 skills are a ChatGPT reimplementation of the documented workflows, not identical to the original Claude content.
- MCP tools are **read-only**, and cannot search the web, write project files, simulate real interviews, or replace a proper cohort/revenue model.
- Public distribution of bundled local MCP plugins is subject to OpenAI's desktop-only submission requirements and potential approval. This repository is intended for **manual local development / personal marketplace use**.
- Tested locally with Node.js and direct MCP STDIO test clients. **It has not been tested inside every supported ChatGPT Desktop host, account or operating system.**
## 15. Publishing this source repository on GitHub (for maintainers)
This section is for the person publishing Founder Intelligence; ordinary users should follow sections 2–10.
1. Create an **empty public GitHub repository** named `founder-intelligence` (do not pre-create a README or `.gitignore` on GitHub).
2. Put `plugin.json`, `mcp.json`, `README.md`, `LICENSE`, `package.json`, `skills/`, `scripts/`, `mcp/`, `tests/`, `examples/`, and `references/` **at repository root**. Do not wrap them in an extra `founder-intelligence-local-v1.1.1/` directory.
3. Verify that the GitHub repository is `https://github.com/mohamed-ibn-elazzouzi/founder-intelligence` and that its default branch will be `main`.
4. From the repository root, run:
```sh
git init
git add .
git commit -m "Release Founder Intelligence local MCP v1.1.1"
git branch -M main
git remote add origin https://github.com/mohamed-ibn-elazzouzi/founder-intelligence.git
git push -u origin main
```
For an existing git repository, skip `git init`, `git remote add` and other already-completed setup steps. You will need GitHub authentication to push.
5. Optionally publish a tagged release:
```sh
git tag v1.1.1
git push origin v1.1.1
```
6. Verify a fresh checkout in a **different directory**:
```sh
cd /tmp
git clone https://github.com/mohamed-ibn-elazzouzi/founder-intelligence.git founder-intelligence-clean
cd founder-intelligence-clean
npm test
```
Do not commit credentials, API keys, user datasets, customer files, or local configuration from `~/.codex` or `~/.agents`. The bundled license and attribution should remain visible; this ChatGPT adaptation is not an official release of the original `founder-skill` project.
TDQS
Scored across 5 tools
Each tool targets a distinct stage: financial computation, persona generation, panel aggregation, price sensitivity, and plan review. The only mild overlap is between founder_unit_economics and founder_plan_evaluate (both touch the financial model), but descriptions make clear one computes and the other critiques, so misselection is unlikely.
All tools use a uniform `founder_` prefix with snake_case noun/verb segments (unit_economics, panel_initialize, panel_tally, van_westendorp, plan_evaluate). The pattern is predictable and groups related tools by domain (panel_*).
Five tools is well-scoped for a founder financial-validation domain, and each covers a genuinely different capability rather than being a redundant variant. Nothing feels padded or thin for the stated purpose.
The surface covers computation, persona creation, tallying, pricing analysis, and review, but there is no way to retrieve, list, or export previously created persona cards or accumulated panel data. Agents can supply inputs each call, yet the lifecycle of generated artifacts is a noticeable gap.