LastPM — Product Judgment That Lives in Your Repo

73 specialized agents. One Canvas Vault. Zero theater.
Strategy that knows your files, not just your last prompt.

The Canvas Flywheel

Most AI tools forget everything the moment you close the tab. LastPM is different.

Every artifact you generate — a market sizing, a PRD, a competitive landscape — writes structured insights back to your Canvas Vault: a set of markdown files living in your repo. The next time an agent runs, it silently pre-fills its inputs from those files. The more you use it, the less you're asked. The context compounds.

Session 1: competitive_landscape_strategist writes Direct Competitors table → competitive_landscape.md
Session 2: differentiated_positioning_canvas auto-loads competitive_landscape.md → no re-input needed
Session 3: b2b_sales_enablement_drafter auto-loads positioning + personas → instant context

This is the flywheel: each run makes the next one faster and more grounded.

Architecture

LastPM v3 is a two-layer system: Python owns all orchestration (routing, canvas, sync), Claude handles generation only.

┌──────────────────────────────────────────────────────────────┐
│                  User Interfaces                             │
│   Cursor Agent    Claude Code    Claude Desktop    CLI       │
└────────────┬─────────────────────────────────────┬──────────┘
             │ MCP tools (73 agents)               │ CLAUDE.md fallback
             ▼                                     │
┌─────────────────────────────┐                   │
│     lastpm/mcp/server.py    │                   │
│  Primary interface — streams│                   │
│  73 tools, one per agent    │                   │
└──────────────┬──────────────┘                   │
               │                                  │
               ▼                                  ▼
┌──────────────────────────────────────────────────────────────┐
│                  Python Engine (zero model tokens)           │
│                                                              │
│  lastpm/router/                 lastpm/canvas/              │
│    intent_matcher.py              reader.py                 │
│    (regex + embedding)            (Pydantic auto-fill)      │
│    scorer.py                      sync.py                   │
│    (structured JSON output)       (validated write)         │
│    agent_loader.py                models.py                 │
│    (SKILL.md YAML parser)         (7 canvas models)         │
└──────────────────────────────┬───────────────────────────────┘
                               │  single API call (generation only)
                               ▼
                    ┌─────────────────────┐
                    │   Claude API        │
                    │   stream=True       │
                    │   artifact text     │
                    └──────────┬──────────┘
                               │
               ┌───────────────┼───────────────────┐
               ▼               ▼                   ▼
┌─────────────────┐  ┌──────────────────┐  ┌──────────────────┐
│  claude/skills/ │  │  Canvas Vault    │  │ claude/memory/   │
│                 │  │                  │  │                  │
│  73 SKILL.md    │  │ 01_Global_       │  │ feedback.jsonl   │
│  frameworks +   │  │   Context/       │  │ (auto-appended)  │
│  YAML metadata  │  │ 02_Product_      │  │                  │
│                 │  │   Workspace/     │  │ skill_health_log │
└─────────────────┘  │   *.yaml files   │  └──────────────────┘
                     └──────────────────┘

9 Layers

Setup

Cursor (2 steps)

1. Open this folder as a workspace in Cursor.
2. Open Composer in Agent mode (not Chat). That's it — CLAUDE.md is auto-loaded as a workspace rule.

No manual wiring required. Cursor reads CLAUDE.md from the workspace root automatically.

Claude Code (3 modes)

Standard (Anthropic API):

# Mac / Linux
export ANTHROPIC_API_KEY=your_key
./install.sh

# Windows (PowerShell)
$env:ANTHROPIC_API_KEY = "your_key"
.\install.ps1

Offline (Ollama):

./install.sh local        # Mac / Linux
.\install.ps1 local       # Windows

Requires Ollama with gemma3 pulled: ollama pull gemma3

With full MCP integrations (Jira, Linear, Brave, Puppeteer):

./install.sh mcp          # Mac / Linux
.\install.ps1 mcp         # Windows

Register as MCP server in Claude Desktop / Cursor (recommended for power users):

export ANTHROPIC_API_KEY=your_key
./install.sh register-mcp          # Mac / Linux

$env:ANTHROPIC_API_KEY = "your_key"
.\install.ps1 register-mcp         # Windows

This registers all 73 agents as MCP tools in your Claude Desktop or Cursor MCP config. Restart your client — you'll see lastpm_* tools appear in the tool list.

If you prefer to launch Claude Code directly: CLAUDE.md is auto-loaded from the project root. No boot script required.

First Run

On first use, if your vault is empty, the system asks:

"Want me to run a quick setup so I have your product context loaded for every session? Takes about 10 minutes and you can skip any question."

Accept to run the context_setup_wizard. It walks you through populating your Canvas files (company profile, personas, competitive landscape, pricing, growth metrics). These become the auto-loaded baseline for all 73 agents — eliminating repetitive re-entry of the same context.

The Vault

Your product and company data lives in two directories that are gitignored:

01_Global_Context/
  01_Company_Context/     # company_profile.md, business_model_canvas.md
  02_Product_Context/     # Per-product canvas files (personas, vision board, etc.)
  03_Venture_Strategy/    # Venture-scope artifacts (market sizing, competitive landscape, etc.)

02_Product_Workspace/
  [Product]/
    01_Global_Domains/    # Product-level strategic artifacts
    02_Initiatives/       # Per-feature PRDs, specs, launch artifacts
    03_Enablement/        # Frontline output: LinkedIn posts, release notes, change comms

These are never committed. Back them up separately (a private repo, iCloud, or Dropbox).

The Agent System

73 agents across 10 domains:

See claude/rules/agent_index.md for the full 73-row routing table.
See claude/rules/agent_registry.md for detailed descriptions and use cases.

How Routing Works

You write in plain English. The orchestrator maps your input to the best framework:

Direct route: "I need to size the market for our Series A deck" → tam_sam_som_analyst

Scored route: "Help me turn this idea into a PRD" → scores 5 dimensions (Defensibility, Feasibility, Monetization, Distribution, Delight) → routes to the weakest dimension's agent first → loops until all ≥ 7 → PRD is written.

The lowest-scoring dimension is named explicitly: "Delight is the critical gap here — you haven't validated this with real customer behavior. Running Teresa Torres's Opportunity Solution Tree to structure the discovery."

Running Evals

The Python eval harness runs all 30 routing cases against the Python router (no Claude tokens):

pip install -e .
python -m lastpm.evals.run_routing_evals

Output: pass/fail per case + claude/evals/results.json with the pass rate. The badge at the top of this README reflects the last committed result.

Before contributing routing changes, run the harness and confirm the pass rate holds. See claude/evals/README.md for the full validation guide.

Adding a New Agent

1. Create claude/skills/your_agent_name/SKILL.md with the YAML header:

   ---
   name: your_agent_name
   description: "One-line trigger description"
   ---
   ---
   agent_name: your_agent_name
   framework: Framework Name (Creator)
   domain: Domain Name
   scope: Venture | Global | Initiative | Frontline
   purpose: One sentence purpose.
   mcp_tool_name: lastpm_your_agent_name
   input_schema:
     input_one: {type: string, required: true, source: ALWAYS_FROM_PM}
   sync_outputs: []
   output_type: strategic_artifact | frontline_artifact | system_artifact
   data_sources: []
   ---
   

2. Add a row to claude/rules/agent_index.md (ID, Description, Domain, Scope, Routing Tag).

3. Add semantic triggers and action tag to claude/rules/intent_dictionary.md.

4. Verify routing by adding a test case to claude/evals/routing_golden_set.jsonl and running the eval.

Contributing

• Run evals before submitting routing changes
• Log routing failures in claude/memory/feedback.jsonl
• Review claude/memory/skill_health_log.md monthly for agents with high revision rates or disputed routing

License

MIT — see LICENSE

Clone. Install. Build with exceptional taste.