# Pabs [Health: Active]

**Category:** 💻 Developer Tools  
**Repository:** https://github.com/pdunovits/pabs-mcp  
**GitHub Stars:** 0  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/pabs

## Description
The decision layer between an idea and a digital product that works.

## Claude Desktop Quick Installation
Remote MCP endpoint (confidence: high). Install path detected from listing signals. Add as a URL/SSE server in your client:

```json
"mcpServers": {
  "pabs": {
    "url": "https://pabs.co.nz"
  }
}
```

## Documentation & README

# PABS MCP Server

**Give your AI coding tools live access to your product strategy.**

[PABS](https://pabs.co.nz) is a product strategy platform that turns a brief into a full strategy — hypotheses, competitor analysis, PRD, and a living pulse of your venture's health. The MCP server exposes that strategy to any MCP-compatible AI tool so it can build with context, not guesses.

When your AI builder knows the target audience, design hypotheses, and current strategic verdict, it makes better decisions. When it spots a gap between what was planned and what was built, it can report it back — and PABS queues it for your review.

---

## Connection

**Transport:** Streamable HTTP (MCP 2025 spec)
**Server URL:** `https://pabs.co.nz/api/mcp/{your-token}`
**Authentication:** Bearer token (one per plan, generated in the PABS app)

### Get your token

1. Open your plan in [PABS](https://pabs.co.nz)
2. Go to the **Connect** tab (or click the plug icon)
3. Click **Generate Token**
4. Copy the server URL — it includes your token

---

## Connect to your AI tool

### Claude Desktop

Add to `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "pabs": {
      "type": "streamable-http",
      "url": "https://pabs.co.nz/api/mcp/YOUR_TOKEN"
    }
  }
}
```

### Claude Code

```json
{
  "mcpServers": {
    "pabs": {
      "type": "streamable-http",
      "url": "https://pabs.co.nz/api/mcp/YOUR_TOKEN"
    }
  }
}
```

### Cursor

Add to `.cursor/mcp.json` in your project (or global settings):

```json
{
  "mcpServers": {
    "pabs": {
      "type": "streamable-http",
      "url": "https://pabs.co.nz/api/mcp/YOUR_TOKEN"
    }
  }
}
```

### Windsurf

Add to `~/.codeium/windsurf/mcp_config.json`:

```json
{
  "mcpServers": {
    "pabs": {
      "serverUrl": "https://pabs.co.nz/api/mcp/YOUR_TOKEN"
    }
  }
}
```

### Replit Agent

1. Go to **replit.com/integrations** → MCP Servers
2. Click **Add MCP Server**
3. Enter a name (e.g. `PABS - My App`)
4. Server URL: `https://pabs.co.nz/api/mcp/YOUR_TOKEN`
5. Click **Test & Save**

### Any MCP-compatible client

The server speaks the MCP 2025 Streamable HTTP transport. Send POST requests to the server URL with a `Bearer` token in the `Authorization` header, or embed the token directly in the URL path (as shown above).

---

## Tools

### Read your strategy

| Tool | What it returns |
|------|----------------|
| `get_full_context` | Everything in one call: brief, strategy, competitor analysis, documents, decisions, hypotheses, action plan, latest pulse, recent learnings. **Recommended starting point.** |
| `get_brief` | Problem statement, target audience, goals, constraints, timeline |
| `get_product_strategy` | Design hypotheses, customer goals, pain points, design vision, success metrics, experience principles |
| `get_competitor_analysis` | Market intelligence, competitive positioning, opportunity analysis |
| `get_prd` | Product Requirements Document generated for AI code builders |
| `get_documents` | All generated documents: PRD, Statement of Work, Venture Brief |
| `get_decisions` | Key assumptions, information gaps with priority/impact, recommended next steps |
| `get_hypotheses` | Design hypotheses with target audience and success indicators |
| `get_action_plan` | Staged activities with tools, durations, and deliverables |
| `get_pulse` | Current strategic Pulse: verdict, recommended next move, activation level |
| `get_learnings` | All captured learnings — evaluated and decided — with the full decision history |
| `get_pending_learnings` | Learnings PABS has evaluated but that need a human decision |
| `get_pulse_schedule` | Current Pulse cadence: day, time, timezone, frequency, next run |

### Act on strategy

| Tool | What it does |
|------|-------------|
| `ask_pabs_agent` | Ask a strategic question. Returns alignment score, recommendations, and considerations. Automatically captures observations or implementation drift. |
| `report_learning` | Push a real-world observation into the strategy feedback loop. PABS evaluates its impact and queues it for the founder to review. |
| `decide_learning` | Approve, reject, or modify a pending learning inline — without opening PABS. |
| `trigger_pulse` | Queue a fresh strategic Pulse after a significant build session or analytics review. |

### Schedule

| Tool | What it does |
|------|-------------|
| `schedule_pulse` | Set the agentic Pulse cadence (frequency, day, hour, timezone). |

---

## The feedback loop

PABS is designed for a two-way relationship between AI builders and the strategy layer.

**Outbound (strategy to builder):** The builder calls `get_full_context` at the start of a session to load the current strategy, hypotheses, target audience, and decisions. It builds with that context.

**Inbound (builder to strategy):** As the builder works, it can call `ask_pabs_agent` to check whether a proposed feature aligns. If it observes something real — a drop-off, a pattern, a change in scope — it calls `report_learning`. PABS evaluates the learning against the strategy, proposes an adaptation, and notifies the founder.

**Human in the loop:** Strategy only updates after the founder reviews and approves a learning. `get_pending_learnings` and `decide_learning` let that review happen inline, inside the builder session.

---

## Authentication

Each plan has a unique token. Tokens do not expire by default. You can revoke and regenerate a token at any time from the PABS Connect tab.

The server URL with the token embedded (`/api/mcp/{token}`) is the recommended format — it lets AI clients distinguish between multiple plans as separate servers.

Alternatively, pass the token in the `Authorization` header as `Bearer {token}`, or in the `X-PABS-Token` header.

---

## Security

- Each token is scoped to a single plan. A token cannot access data from any other plan.
- The server validates the token on every request before any data is returned.
- All requests go over HTTPS.

---

## Requirements

- An active [PABS](https://pabs.co.nz) account
- At least one saved plan with a brief
- A token generated from the Connect tab

---

## Links

- [PABS app](https://pabs.co.nz)
- [Integrations overview](https://pabs.co.nz/docs/integrations-overview)
- [Health check](https://pabs.co.nz/api/mcp/health)
- [Server info](https://pabs.co.nz/api/mcp/info)

---

## License

This repository documents the hosted PABS MCP server. The server is proprietary and operated by PABS. Client configuration examples in `examples/` are released under MIT.