Skip to main content
Glama

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, 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.

Related MCP server: cryptbrew-mcp

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+ and Git. 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:

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. These commands will work after the repository has been published with the project files at its root.

A. Clone the public repository:

git clone https://github.com/mohamed-ibn-elazzouzi/founder-intelligence.git
cd founder-intelligence

Check that the repository root contains the expected files:

ls plugin.json mcp.json mcp/server.mjs scripts/install-local.mjs

B. Check the runtime and execute the tests:

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:

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:

git clone https://github.com/mohamed-ibn-elazzouzi/founder-intelligence.git
cd .\founder-intelligence

B. Run tests and install:

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:

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:

[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:

{
  "$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

{
  "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

{
  "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

{
  "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

{
  "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

{
  "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.

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

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:

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.

  1. Optionally publish a tagged release:

git tag v1.1.1
git push origin v1.1.1
  1. Verify a fresh checkout in a different directory:

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.

Available Tools

5 tools
founder_panel_initializeB

Create deterministic synthetic buyer persona cards; not actual survey responses or customer validation.

Inputs: pitch (required), customer (required), n, seed.

founder_panel_tallyB

Aggregate supplied synthetic/actual tagged panel answers (yes/no/undecided); results are not evidence of market demand unless independently verified.

Inputs: answers (required).

founder_plan_evaluateB

Review existing financial model and panel result with explicit checklist, without writing local files; verdict refers only to modeled outcomes.

Inputs: panel (required), finance (required), min_buy_rate.

founder_unit_economicsA

Compute deterministic unit economics, 12-month forecast, break-even, cash requirement and sensitivity scenarios. Requires fully specified financial assumptions; never invent inputs.

Inputs: financials (required).

founder_van_westendorpB

Compute empirical Van Westendorp price intersections from user-supplied 4-question survey data. Synthetic entries must be identified as synthetic.

Inputs: responses (required), data_origin, tested_price.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.5/5.0

    Scored across 5 tools

    Disambiguation4/5

    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.

    Naming Consistency5/5

    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_*).

    Tool Count5/5

    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.

    Completeness3/5

    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.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    • BusCalc 1.8.0 exposes 33 public tool families: 26 calculations and seven attributed data lookups. Calculate business pricing, finance, uncertainty, lease economics and emergency dispatch margins. Look up metals, energy, exchange rates, weather, BLS, USDA, Census and selected emergency sources, including NOAA gauges and USGS flood-impact points. Calculations include unsigned replayable receipts. Lookup results include source and observation dates where available. Road and outage coverage varies by location. The public Streamable HTTP endpoint is https://buscalc.com/api/mcp. Direct access is anonymous and rate limited. Full guide: https://buscalc.com/for-ai/

      https://buscalc.com/api/mcp
    • Financial data MCP server for Claude, ChatGPT, Cursor and Codex. Real-time stock quotes, financial statements, options flow, SEC filings, insider trades, 13F holdings, macro data and market news from gloom.sh, the open-source Bloomberg Terminal alternative.

      https://api.gloom.sh/mcp
    • Read-only MCP server that answers questions about turva.dev from its published data. Five tools return JSON: the service catalog with prices, contact and operator details, engagement principles and dated agent-readiness and security evidence with verification links. Connect over Streamable HTTP. You need no API key. The server does not scan other websites or run audits.

      https://mcp.turva.dev/mcp
    • 55 stateless calculators for AI agents: loans and mortgage amortization, income and sales tax, retirement and FIRE, BMI and health, date and planning, and unit conversions, returned as clean JSON. Nothing is stored. Part of FreeDailyPro's 211+ MCP tools; trial key with 20,000 calls/month at freedailypro.com/developers.

    Related MCP Servers

    • F
      license
      Not graded
      quality
      D
      maintenance
      Provides two MCP tools for querying a synthetic marketing SQLite database and running agent evaluation cases, with read-only SQL guarding and deterministic planning. The server communicates over stdio and supports initialization handshake and tool listing.
      -
    • A
      license
      A
      quality
      C
      maintenance
      Enables AI agents to answer Cryptbrew product questions and check live API health without merchant authentication. Exposes tools for pricing, FAQs, invoice flow, and health probes over stdio or streamable HTTP.
      8
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Exposes long-term stock analyses (log-price regression, valuation in σ, annualized trend, 5/10-year potentials), ticker search, a French-universe screener, thesis drafting, and portfolio reads/writes to an AI client over stdio, with an optional read-only mode. The server performs no model calls itself, acting as persistent local memory and computation while the AI reasons and proposes.
      AGPL 3.0
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI clients to run social-media ROI evaluations, multi-account matrix comparisons and budget allocation, search-index and e-commerce spillover estimates, and GEO share-of-voice analysis through a zero-dependency stdio JSON-RPC interface.
      1
      MIT