# ChatGPT GPT Actions: ThumbGate Install

Open the published ThumbGate GPT directly:

https://chatgpt.com/g/g-69dcfd1cd5f881918ae31874631d6f08-thumbgate

Use the GPT as the public front door: paste a risky AI action to check, prevent an expensive mistake before it runs, save a thumbs-up/down lesson, write a Pre-Action Check, install ThumbGate for an agent, or export proof.

Users do **not** have to keep chatting inside the ThumbGate GPT for enforcement. The GPT is advice, checkpointing, guided setup, and ChatGPT memory capture. Real enforcement for coding agents still runs locally through ThumbGate hooks after `npx thumbgate init`.

Use the term **Reliability Gateway** only after the user understands the outcome: ThumbGate is the approval layer between AI intent and costly execution.

Marketing rule: every landing page, README, social post, and plugin listing should point to the live GPT before asking a cold user to read OpenAPI docs.

## Regular-user promise

The GPT should feel like a feedback button that remembers.

- Users paste the answer, plan, or action they want checked.
- Users type `thumbs down:` when the answer was wrong and one sentence about what should change.
- Users type `thumbs up:` when the answer was useful and one sentence about what should be repeated.
- ThumbGate confirms the future behavior it saved, then routes users to `npx thumbgate init` when they need hard blocking outside ChatGPT.

Do not imply ChatGPT's built-in thumbs buttons save ThumbGate lessons. The reliable public capture path is a typed message inside the GPT.

Critical failure rule: if the `captureFeedback` Action fails with `401`, `403`, `5xx`, timeout, missing action, or any setup/auth error, the GPT must not say it saved the lesson, will remember the lesson, or can still apply it going forward. It must say: "Not saved in ThumbGate yet." Then it should state the setup failure and point the GPT owner to the Action auth repair steps below. Do not ask the user whether to turn failed feedback into a hard rule.

## GPT Store path

1. Open the direct GPT URL: https://chatgpt.com/g/g-69dcfd1cd5f881918ae31874631d6f08-thumbgate
2. If ChatGPT does not open it for your account, open **Explore GPTs**.
3. Search for `ThumbGate`.
4. Choose the GPT by **Igor Ganapolsky** in the **Programming** category.

## 30-second user flow

1. Paste a proposed AI action, command, merge, deploy, file edit, email, payment, or API call.
2. ThumbGate evaluates whether to allow, block, or require a checkpoint before the action runs.
3. After any answer or agent run, reply with `thumbs up:` or `thumbs down:` plus one concrete sentence.
4. ThumbGate saves the lesson, refreshes prevention rules when patterns repeat, and can show what it remembers.
5. When the user is ready to enforce outside ChatGPT, send them to `npx thumbgate init` for Claude Code, Cursor, Codex, Gemini CLI, Amp, OpenCode, or another MCP-compatible agent.

Regular users should never need to know MCP, OpenAPI, Actions, DPO, Thompson Sampling, or schema validation. The GPT should explain the loop as: "One signal becomes one remembered rule. Fix it once; block the repeat before the next tool call."

## GPT profile card

Use this copy in GPT Builder instead of the generic "AI safety gate" or "reliability layer" framing:

Short description:

```text
Stop costly AI mistakes before they run
```

Full description:

```text
Paste a risky AI action before it runs. ThumbGate tells you whether to allow, block, or checkpoint it, then turns thumbs-up/down feedback into Pre-Action Checks so repeated mistakes stop coming back.
```

Conversation starters:

1. `Check this agent action before it runs: git push --force --tags`
2. `Thumbs down: that answer ignored my request for exact commands. Remember that.`
3. `Thumbs up: this answer gave file paths, commands, and tests. Do that again.`
4. `Turn this mistake into a ThumbGate rule: the agent edited generated files again.`

Use typed chat replies. ChatGPT's native feedback buttons may send feedback to OpenAI, but they should not be described as the ThumbGate capture path unless OpenAI exposes them to GPT Actions.

GPT avatar:

```text
public/assets/brand/thumbgate-icon-512.png
```

Upload the canonical dark rounded-square TG gate monogram above. Do not use `docs/logo-400x400.png`, `.claude-plugin/bundle/icon.png`, a generic cube, emoji thumbs, or a generated image. Expected SHA-256: `6f0290f7fe50de9a82c18be2299deafba4c686df46b3b5309e363a7d589d89dc`.

## Pre-action check flow

Use this when the user asks whether an AI agent should run a proposed action, command, file edit, deployment, merge, or publish step:

1. The GPT calls `evaluateDecision` (`POST /v1/decisions/evaluate`) before answering.
2. If the response has `decisionControl.executionMode: "blocked"`, the GPT says the action is blocked and explains the returned reason.
3. If the response has `decisionControl.executionMode: "checkpoint_required"`, the GPT asks for explicit confirmation before proceeding.
4. If the response has `decisionControl.executionMode: "auto_execute"`, the GPT can say the action is allowed and summarize why.

Plain thumbs-up/down feedback is the memory loop. The decision endpoint is the check loop. Do not claim hard blocking unless the decision endpoint, a saved lesson, or a prevention rule was actually applied.

## Best first GPT message

Use this as the first response:

```text
Paste the risky AI action before it runs, or tell me what went right/wrong. I can prevent costly mistakes, save the lesson, write a prevention rule, or show what ThumbGate already remembers.
```

## Prerequisites

- A ChatGPT Plus or Team account (Custom GPTs require a paid plan)
- ThumbGate API running at `https://thumbgate-production.up.railway.app`
- Privacy policy URL: `https://thumbgate-production.up.railway.app/privacy`
- Owner-managed `THUMBGATE_API_KEY` for one-time GPT Builder Actions auth

Regular GPT users should not need an API key, JSON payload, OpenAPI knowledge, or developer setup. They should only see the action-checking path, the thumbs-up/down memory loop, and the handoff to local enforcement when they need hard blocking.

## Step 1 — Open GPT Builder

1. Go to [https://chat.openai.com/gpts/editor](https://chat.openai.com/gpts/editor)
2. Click **Create a GPT**
3. Switch to the **Configure** tab

## Step 2 — Add Actions

1. Scroll to the **Actions** section
2. Click **Create new action**
3. Click **Import from URL** — paste your hosted spec URL:
   ```
   https://thumbgate-production.up.railway.app/openapi.yaml
   ```
   Or click **Upload file** and select:
   ```
   adapters/chatgpt/openapi.yaml
   ```

## Step 3 — Set Authentication

In the Actions panel:

1. Select **Authentication type: API Key**
2. **Auth type**: Bearer
3. **API Key**: paste the raw `THUMBGATE_API_KEY` value only, without a `Bearer ` prefix

Expected outbound header:

```text
Authorization: Bearer <THUMBGATE_API_KEY>
```

This is an owner setup field. Do not ask regular GPT users to provide an API key.

## Step 4 — Update the Server URL

In the imported spec, confirm the `servers.url` points to your deployed API:

```yaml
servers:
  - url: https://thumbgate-production.up.railway.app
```

If you uploaded the file, edit the server URL in the GPT Actions editor.

## Step 5 — Verify

Click **Test** on the `captureFeedback` action:

```json
{
  "signal": "up",
  "context": "GPT Actions install verified with a successful test call",
  "whatWorked": "The hosted action returned accepted=true and a promoted status"
}
```

Expected response: `200 OK` with `{ "accepted": true, "status": "promoted" }`.

If you only send a bare `thumbs up/down` style payload, expect `422` with `status: "clarification_required"` and a follow-up `prompt`.

Before publishing or re-publishing the GPT, keep it private and verify these three private flows in GPT Builder:

1. `Thumbs up: this answer gave exact commands, file paths, and tests`
2. `Thumbs down: that answer ignored the requested auth setup`
3. `Check this: git push --force`

All three should call the action layer without a `401 Unauthorized` response. If any action test returns `401`, the GPT Builder secret is missing, stale, pasted with an extra `Bearer ` prefix, or pointed at a different backend key than Railway's `THUMBGATE_API_KEY`.

Expected user-facing failure copy when an Action is unhealthy:

```text
Not saved in ThumbGate yet. The GPT Action is not authenticated, so I cannot persist this lesson. The GPT owner needs to update Actions auth to API Key -> Bearer with the raw THUMBGATE_API_KEY, re-import https://thumbgate-production.up.railway.app/openapi.yaml, and retest captureFeedback.
```

## Available Actions

| Action | Method | Path | Description |
|---|---|---|---|
| `captureFeedback` | POST | `/v1/feedback/capture` | Capture up/down signal plus one-line why |
| `getFeedbackStats` | GET | `/v1/feedback/stats` | Aggregated feedback statistics |
| `getFeedbackSummary` | GET | `/v1/feedback/summary` | Recent feedback summary |
| `generatePreventionRules` | POST | `/v1/feedback/rules` | Generate prevention rules |
| `exportDpoPairs` | POST | `/v1/dpo/export` | Export DPO preference pairs |
| `listIntentCatalog` | GET | `/v1/intents/catalog` | List available intents |
| `planIntent` | POST | `/v1/intents/plan` | Generate policy-scoped plan |
| `constructContextPack` | POST | `/v1/context/construct` | Build context pack |

Full spec: `adapters/chatgpt/openapi.yaml`

## Troubleshooting

- **401 Unauthorized on action calls**: Verify the GPT Builder action uses **Authentication type: API Key**, **Auth type: Bearer**, and the raw `THUMBGATE_API_KEY` value. The backend must receive `Authorization: Bearer <key>`.
- **401 Unauthorized when importing the schema**: Use `https://thumbgate-production.up.railway.app/openapi.yaml` after the public spec route is deployed, or fall back to `https://thumbgate-production.up.railway.app/openapi.json`.
- **Connection refused**: Confirm Railway deployment is live (`curl https://<domain>/health`)
- **Schema errors**: Ensure you are using the latest `openapi.yaml` (version 1.1.0+)
