__GOOGLE_SITE_VERIFICATION_META__
__GA_BOOTSTRAP__
👍 👎 The Firewall for AI Agents

# The Infrastructure Firewall for AI Coding Agents.

AI agents will always hallucinate and break things — we make their mistakes harmless. ThumbGate runs in the PreToolUse hook on your machine and blocks the dangerous tool call — rm -rf, leaked keys, off-scope edits, a bad git push — before it executes. No server, no gateway, no waiting on an enterprise rollout.

$ agent attempts risky action
BLOCKED: never run DROP on production tables
Agent must choose a safer plan with evidence.
Start Pro — $19/mo Talk to me — Workflow Hardening Sprint → Install Free CLI
Solo operator: Start Pro

Sync, proof, exports.

Pay $19/mo with Stripe →
Enterprise: Start with intake

Shared enforcement, scoped.

Talk to us →
Still evaluating: Free CLI

Local proof first.

MIT open source Local-first Works with MCP-compatible agents Verification evidence in GitHub

> “A better dashboard doesn’t make the agents more reliable. The hard part isn’t visibility. It’s trust.”

— Rob May, CEO & co-founder, Neurometric AI, in The New Stack on Anthropic’s Claude Code Agent View (May 2026). ThumbGate is the open-source layer that makes the trust part real: PreToolUse gates, thumbs-down to rule, audit trail on every interception.

Local-first is the new default

> Perplexity demoed a Personal Computer agent at Computex 2026 that asks the user before sending sensitive content to the cloud. Automation Anywhere shipped EnterpriseClaw with Cisco, NVIDIA, Okta, and OpenAI — central policy, locally enforced, audit reported back. The architectural debate is settled. ThumbGate runs the same pattern for the coding agent already on your laptop.

Sources: Perplexity at Intel Computex keynote (2026-06-02), Automation Anywhere EnterpriseClaw launch (Imagine 2026), The New Stack coverage.
First-Dollar Activation Path

## Block your first repeated AI mistake in 5 minutes.

Install, give one thumbs-down, and let the PreToolUse hook stop that failure from rerunning. Upgrade only when you need dashboards, exports, or shared team enforcement.

1. Install ThumbGate

Run `npx thumbgate init` in your repo. Claude, Cursor, Codex, Gemini, Amp, Cline, and OpenCode are supported through local hook or MCP-compatible setup paths.

2. Give feedback

Use thumbs up for a good pattern and thumbs down for a failure. ThumbGate distills the correction into a concrete prevention rule.

3. The repeat gets blocked

The next matching tool call is stopped before execution, with a reason the agent can use to choose a safer plan.

👍👎
Thumbs-down once, blocked forever Block repeat hallucinations before the model sees them

For consultancies, platform teams, and AI product teams that want workflow governance, CLI-first rollout, and a reliable operator.

Have one AI-agent failure that keeps repeating? Start with one real workflow, one repeated failure pattern, enforceable pre-action gates, and a short audit trail your team can keep.

Prove one blocked repeat before asking anyone to buy. Give `thumbs up` when the agent follows your standards, `thumbs down` when it misses. Upgrade after one real blocked repeat.

Workflow governance for isolated execution: ThumbGate pairs policy checks with Docker Sandboxes, signed hosted sandbox dispatch, Changeset evidence, and exact main-branch merge commit verification before release claims ship.

ctaId: 'hero_workflow_sprint' ctaId: 'hero_workflow_sprint_recovery_intake' workflow_sprint_intake_started workflow_sprint_recovery_intake_clicked hero_workflow_sprint_recovery_intake dashboard-preview What your Pro dashboard looks like check:no-force-push Start Enterprise Pilot Intake id="team-pilot-intake-form" data-team-intake-form name="ctaPlacement" value="team_visible_intake" name="utmMedium" value="visible_team_intake" name="planId" value="team" name="ctaId" value="workflow_sprint_intake" Enterprise checkout happens after scope. team_workflow_sprint_recovery_intake scope_first workflow_sprint_intake_started workflow_sprint_intake_submit_attempted pricing_team_intake team_intake_started No, you do not have to chat inside the GPT forever. ChatGPT is the discovery and memory surface. Do not rely on ChatGPT's native rating buttons for ThumbGate memory. Explore GPTs choose the GPT by Igor Ganapolsky Programming Do I have to chat inside the ThumbGate GPT for enforcement? capture thumbs-up/down lessons Real blocking for coding agents still runs locally adapters/chatgpt/INSTALL.md Native ChatGPT rating buttons are not the ThumbGate capture path. thumbs up: this review named exact files, commands, and tests. thumbs down: the answer ignored my request.
Agentic Development Cycle

## Guide, Generate, Verify, Solve still needs an execution gate.

The market is converging on agentic development as a control loop, not a code-generation trick. The New Stack's May 2026 AC/DC framing names the core stages: Guide, Generate, Verify, and Solve. ThumbGate gives that loop a hard pre-action boundary so agent work is governed before it touches files, terminals, CI, payments, or production systems.

### Guide

Rules, standards, past thumbs-downs, workflow boundaries, and approval policies are loaded as concrete operating context instead of vague prompt advice.

### Generate

Claude Code, Cursor, Codex, Gemini, Amp, Cline, OpenCode, and MCP-compatible agents keep generating plans, edits, and tool calls.

### Verify

Pre-Action Checks require inspection evidence, tests, CI, screenshots, API responses, or human approval before high-risk actions proceed.

### Solve

Blocked failures and accepted fixes become lessons, shared rules, DPO exports, and audit events so the same mistake is not paid for again.

ThumbGate's role: the pre-action gate between generated intent and executed action.

Verification after a pull request is useful, but it is too late for force-pushes, destructive SQL, unsafe deploys, leaked secrets, and costly external API calls. ThumbGate checks the action before it runs, then feeds the result back into the next Guide and Solve cycle.

terminal — see it work in 30 seconds
# Install in 30 seconds
npx thumbgate init
# Your agent tries to delete production db...
⛔ Check blocked: "Never run DROP on production tables"
# Rule auto-generated from your previous 👎
# That's it. One thumbs-down = one permanent check.

This is the entire product in 2 lines. Install, give feedback, checks auto-generate.

Deterministic Prevention

## Native thumbs are a black box. ThumbGate is the inspectable control layer.

Codex, Claude Code, ChatGPT, and other agent surfaces can collect preference signals, but you usually cannot see exactly what changed, which rule will fire, or why a future tool call is allowed. ThumbGate keeps the prevention layer outside the model: typed feedback becomes a local lesson, repeated mistakes become explicit rules, and every block names the matched rule, source lesson, tool call, and audit event.

### Black-box memory

Native thumbs and vendor memories may improve future behavior, but they do not give teams a deterministic allow/block contract at the moment an agent touches files, terminals, APIs, or CI.

### Inspectable ThumbGate memory

Lessons live in your ThumbGate store, can be searched, exported as JSONL or DPO pairs, and traced back to the exact correction that created the rule.

### Rules before execution

The final decision is not another model opinion. ThumbGate checks tool name, arguments, working directory, command shape, confidence, and required evidence before the action runs.

### Why this matters now

- Agent security is now mainstream risk. Coding agents run shell commands, write files, query databases, and chain actions with developer permissions, so unattended autonomy needs a local policy boundary.
- MCP adoption is accelerating. More tools are becoming agent-callable through shared protocols, which means one cross-agent governance layer beats one-off prompt rules per app.
- Repeated failures waste cash and trust. Every repeat burns tokens, review time, and release confidence. ThumbGate turns the first correction into a reusable prevention check.

Sources to verify the market timing: Docker on AI coding agent security risks, TechRadar on enterprise agent security pressure, and current MCP adoption coverage.

Status bar proof

## See the footer before you ship the next repeat.

Claude renders the live ThumbGate footer now. `npx thumbgate init --agent codex` installs the same Codex hook bundle and writes the ThumbGate `statusLine` target so you can test it on your local Codex build immediately.

Claude live footer with ThumbGate stats, links, and the latest mistake summary.
Codex test lane after the published ThumbGate install path writes PreToolUse, UserPromptSubmit, PostToolUse, SessionStart, and the statusLine target.
Claude Code · Claude Desktop · Claude Extension

## The fastest path for Claude users: install the extension and start blocking mistakes.

ThumbGate ships a published Claude Desktop extension bundle (`.mcpb`) you can install today. Claude Code users can also add the repo marketplace plugin immediately. No waiting for directory approval.

1. Install for Claude Code

Run `npx thumbgate init --agent claude-code` or add via `claude mcp add thumbgate -- npx --yes --package thumbgate thumbgate serve`

2. Or install the Claude Extension

Download the .mcpb bundle for Claude Desktop, or use the repo marketplace: `/plugin marketplace add IgorGanapolsky/ThumbGate`

3. Give feedback, checks auto-generate

Type `thumbs down` when Claude makes a mistake. ThumbGate distills a lesson from up to 8 prior entries and blocks the pattern permanently via PreToolUse hooks.

Download Claude Extension (.mcpb) Claude Desktop setup guide Claude plugin docs

Claude Code Skill: Type `/thumbgate` in any Claude Code session. Auto-triggers on “check”, “feedback”, “block mistake”. Free skill on top of the same local gateway.

ChatGPT Entry Point · Live ThumbGate GPT for ChatGPT

## Use the GPT as a preflight desk for risky commands, refunds, deploys, and PR actions.

ThumbGate should meet users where they already ask AI for help. The live GPT is the fastest way to preflight a risky action, capture a typed thumbs-up/down lesson, and prove the enforcement loop before installing anything. As ChatGPT ads roll out, this matters more: ChatGPT can stay the discovery and checkpointing layer, while ThumbGate remains the hard execution boundary after `npx thumbgate init`.

1. Open the live GPT

Paste a proposed command, file edit, merge, deploy, refund, invoice, or API call and ask whether to allow, block, or checkpoint it.

2. Save the typed signal

Reply in chat with `thumbs up:` or `thumbs down:` plus one concrete sentence. Do not rely on ChatGPT's native rating buttons for ThumbGate memory.

3. Enforce locally

Run `npx thumbgate init` in the repo so Pre-Action Checks block repeated mistakes before the coding agent executes them.

Open ThumbGate GPT ChatGPT Actions setup Why ChatGPT ads need checks

Find it fast: if the direct link does not open, go to Explore GPTs, search `ThumbGate`, and choose the GPT by Igor Ganapolsky in Programming. Plain English rule: ChatGPT is the discovery and memory surface for advice, checkpointing, and typed feedback capture. One typed signal becomes one remembered rule. The hard Reliability Gateway still runs in the local agent or CI lane.

Compatibility

## One gateway across the agent surfaces you already use

### 🧩 Claude Desktop Extension

Install the published Claude Desktop plugin `.mcpb` bundle today. Claude Code users can add the repo marketplace immediately with `/plugin marketplace add`. No waiting for directory approval. 60-second setup guide →

Download .mcpb bundle →

### ⚡ Claude Code Skill

Type `/thumbgate` in any Claude Code session. Auto-triggers on "check", "feedback", "block mistake". Free skill on top of the same local gateway teams later harden into a shared workflow.

Read the Claude Code guide →

### 🤖 AI CLIs

Claude Code, Codex, Gemini CLI, Amp, and OpenCode all use the same gateway and memory model. Any MCP-compatible agent gets pre-action checks, feedback memory, and enforcement out of the box.

Open the setup guide →

### ☁️ Google Data Agent Kit

Cloud Next 2026 shipped BigQuery, Spanner, AlloyDB, and Cloud SQL as MCP tool calls into Claude Code, Codex, and Gemini CLI. ThumbGate checks the destructive ones — DROP on prod datasets, unscoped DELETEs, IAM escalation — before they fire.

Read the GCP guardrails guide →

### 🧩 Codex plugin

Codex gets a standalone ThumbGate plugin bundle, a repo-local plugin profile, and the same auto-updating MCP launcher. The runtime resolves `thumbgate@latest` when Codex starts, so npm fixes reach active installs. The install page includes the zip, MCP config, and verification path in one place.

Open the Codex install page →

### 🎯 Cursor plugin (Marketplace review pending)

Drop the ThumbGate MCP config into `.cursor/mcp.json` and Cursor gets the same pre-action checks as Claude Code and Codex. Ships with bundled rules, commands, hooks, and agents. The runtime install works today via `npx thumbgate init --agent cursor`; the official Cursor Marketplace listing was submitted 2026-05-19 and is awaiting Cursor's manual review.

Read the Cursor guide →

### ✏️ Editor workflows

VS Code works when you run an MCP-compatible agent inside it (Continue, Cline, etc.). Any editor that speaks MCP stdio gets the same gateway.

Open the setup guide →

### 🗂️ MCP Server Directory

ThumbGate is listed on `mcp.so` so MCP-compatible clients can verify the package, copy the npx config, and confirm they are installing the real Pre-Action Checks server.

View on mcp.so →

### 💬 ChatGPT GPT Actions

Open the ThumbGate GPT to preflight risky commands, deploys, refunds, PR actions, and setup steps, capture thumbs-up/down lessons, and save typed signals. Real blocking for coding agents still runs locally after `npx thumbgate init`.

Open ThumbGate GPT →
See It In Action

## See the enforcement before you buy anything

### 🔍 Live Dashboard Demo

Search lessons, inspect checks, mark a review checkpoint, and see only what changed since the last pass. No signup or install required.

Open Dashboard Demo →

### ⛔ Check Reasoning Chains

Every block explains why: which pattern matched, what evidence triggered it, and whether the rule came from your own corrections.

### 📊 Org Dashboard (Team)

See which agents are creating review churn, which checks are saving time, and where rollout risk is still concentrated across the shared workflow.

### 🧱 Isolated Execution Lanes

High-risk local autonomy can route into Docker Sandboxes, while hosted team automations use a signed sandbox dispatch lane instead of running loose on a shared host.

### Data Processing Boundaries

Local enforcement data stays in the operator's ThumbGate feedback directory by default. Hosted checkout, intake, newsletter, team sync, and product analytics are labeled as hosted processing surfaces instead of being blurred into the local runtime.

### 🧪 Thompson Sampling

Confidence tiers (none/low/medium/high) tell you when to trust the model vs fall back to rules. No guessing.

### 🪞 History-Aware Lessons

When the current Claude auto-capture hook only gets a vague thumbs-down, ThumbGate can reuse up to 8 prior recorded entries plus the failed tool call, then keep a linked 60-second feedback session open for later corrections instead of creating a dead-end note.

Positioning

## Enforcement is the missing layer in AI orchestration.

Big orchestration suites unify data, routes, and decisions. ThumbGate sits closer to the moment of execution: the point where an agent is about to run a shell command, ship a PR, approve a release, or repeat a mistake you already corrected. That is where workflow trust is won or lost.

### Broad orchestration platforms

Good at customer journeys, routing, and cross-system context. Weak when you need a coding agent or automation to stop before a destructive or low-trust action actually runs.

### ThumbGate

Turns operator feedback into Pre-Action Checks. It does not just remember the mistake. It blocks the repeat at the tool-call boundary across Claude Code, Cursor, Codex, Gemini, Amp, Cline, and OpenCode.

### The stack that makes sense

Use orchestration to decide what should happen next. Use ThumbGate to decide what is allowed to execute. That is the control layer enterprises actually need once agents touch repos, terminals, CI, or production workflows.

Compare orchestration vs enforcement → AI deployment readiness → Platform team rollout → Regulated workflow pattern → Built for the Agent Manager →
Compare ThumbGate with other agent-safety approaches
Browse the guide library SpecLock Mem0 Fallow Pre-action checks Agent harness optimization Code graph guardrails Developer machine supply chain Proxy pointer RAG RAG precision tuning Internal AI engineering stack SEO agent skills Claude Code skills Long-running agent context Reasoning compression AI deployment readiness Browser automation safety Native messaging host security AI search topical presence Stop agents breaking production Relational knowledge Claude Code feedback Autoresearch safety
Autoresearch Safety Pack

## Stop self-improving coding loops from hacking the benchmark.

Autoresearch loops run experiments, inspect metrics, and accept better variants. ThumbGate gives those loops a Reliability Gateway: Pre-Action Checks for skipped holdout tests, fake proof, reward hacking, unsafe edits, and promotion without verification evidence.

### Guard the metric

Require primary and holdout checks before an agent can call a variant better. Block cherry-picked runs and missing baselines.

### Preserve proof trails

Promotion needs commands, logs, changed files, and verification evidence so the win survives review instead of becoming a vague claim.

### Ship into CI

Start with templates for `npm test`, Playwright duration, bundle size, lint, and CI failures, then add Team checks for shared workflows.

Read the Autoresearch guide Start Pro
Persistent Agent Skills

## Reusable instructions are the new baseline. Enforcement is the moat.

Grok-style skills are training users to expect persistent expertise across every surface. ThumbGate turns that expectation into a governed reliability layer: capture the correction once, export it as a portable skill or lesson bundle, then prove the next risky tool call was blocked before it ran.

### Portable skill memory

Thumbs-up/down lessons become reusable rules and skill-pack context that can move across Claude Code, Cursor, Codex, Gemini, Amp, Cline, OpenCode, and MCP-compatible agents.

### Instructions plus teeth

Persistent skills tell an agent what you prefer. ThumbGate checks whether the next action follows those preferences and blocks high-risk repeats before execution.

### Proof for teams

Every fired rule carries the source lesson, decision trace, and audit evidence, so teams can review which skill worked instead of trusting a hidden chatbot memory.

Current release

## Three steps to stop repeated AI failures

1

### Feedback

Give `👍` or `👎` on your AI agent's actions. Feedback is stored in a SQLite+FTS5 lesson DB. In the current Claude auto-capture hook, a vague thumbs-down can distill from up to 8 prior recorded entries and the failed tool call before promotion, then stay linked to a 60-second feedback session. Example: you 👎 a risky migration → it auto-promotes to a "never run DROP on prod" check.

2

### Distill + Rules

Repeated failures auto-promote into prevention rules. Thompson Sampling adapts which rules fire, and the reflector lane can propose a reusable rule from the same transcript so high-risk patterns get stricter enforcement while low-risk ones stay relaxed.

3

### Checks

Rules become Pre-Action Checks that block your agent before it repeats the same mistake. Your agent can't force-push, skip tests, or repeat a refactor you already rejected. No more fix-loops.

Enforcement

## Checks block. They don't ask nicely.

### Don't trust — verify

Every block shows why: pattern match, evidence, confidence score.

### Real tools, not wishes

Checks physically block tool calls. Not prompt tricks. Not "please don't."

### Force models to show work

Reasoning chains on every check decision. Thompson Sampling confidence tiers.

### Log everything, learn automatically

Repeated failures auto-promote to checks. Org dashboard shows all agents.

### Keep risky runs off the host

When Workflow Sentinel predicts a risky local action, ThumbGate can recommend Docker Sandboxes before the agent touches the host filesystem or broader credentials.

### Ship with versioned proof

Changesets, SemVer, sync checks, and verification evidence make new package releases inspectable before a buyer trusts the next rollout.

terminal
# Install in 30 seconds
npx thumbgate init
# Your agent tries to delete production db...
⛔ Check blocked: "Never run DROP on production tables"
# Rule auto-generated from your previous 👎
# Works with your existing setup
npx thumbgate init # bootstraps .thumbgate and .mcp.json
# Use repo guides for Claude plugin, Codex app plugin, Cursor plugin, and OpenCode profiles

## Install for Your Agent

### Claude Code

`npx thumbgate init --agent claude-code`

Wires PreToolUse hooks automatically

### Cursor

`npx thumbgate init --agent cursor`

4 skills: feedback, rules, search, recall

### Codex

`npx thumbgate init --agent codex`

6 skills including adversarial review

### Gemini CLI

`npx thumbgate init --agent gemini`

Gemini CLI integration

### Amp

`npx thumbgate init --agent amp`

Amp agent integration

### Any MCP Client

`npx thumbgate serve`

MCP stdio server for any compatible client

### Claude Desktop

Add to your `claude_desktop_config.json`:

    {
      "mcpServers": {
        "thumbgate": {
          "command": "npx",
          "args": ["--yes", "--package", "thumbgate", "thumbgate", "serve"]
        }
      }
    }

Official directory review is separate. Claude Code users can install immediately with `/plugin marketplace add IgorGanapolsky/ThumbGate` and `/plugin install thumbgate@thumbgate-marketplace`.

Pricing

## Stop paying for agent mistakes you already fixed.

| Free $0 forever | Pro $19/mo or $149/yr | Enterprise Custom — scoped after intake
--- | --- | --- | ---
Local PreToolUse enforcement (all agents) | ✅ | ✅ | ✅
Feedback captures | 5/day (25 total) | Unlimited | Unlimited
Active auto-promoted prevention rules | 3 | Unlimited | Unlimited
Lesson recall + search across sessions | — | ✅ | ✅
Personal dashboard + DPO export | — | ✅ | ✅
Hosted sync across machines | — | ✅ | ✅
Shared lesson database + org dashboard | — | — | ✅
Org-wide shared enforcement + approval boundaries | — | — | ✅
Audit trail, SSO, regulatory gate templates | — | — | ✅
Best for | One developer | Solo operators | Teams & regulated orgs

Free
$0
Block repeated mistakes daily. Forever free for solo devs.

5 captures/day, 3 active rules. Enough to see the value — upgrade when you need more.

- 5 feedback captures/day — 25 total on Free, then Pro for unlimited
- Up to 3 active auto-promoted prevention rules
- No recall or lesson search
- No exports (DPO, Databricks, HuggingFace)
- All MCP integrations (Claude Code, Cursor, Codex, Gemini, Amp, any MCP agent)
- PreToolUse hook blocking with built-in safety checks (force-push, destructive SQL, secrets)
- Setup guide for all agents →

$ npx thumbgate init click to copy
Install Free
Pro
$19/mo
Don't buy a tool — buy hosted sync + compatibility insurance. The free CLI runs your gates locally, but Pro is what we operate for you: secure SQLite sync across all your machines (saving you from managing database migrations manually across developer boxes) and active adapter maintenance to stay compatible with weekly breaking updates in Claude Code, Cursor, and Cline.

- Block every repeat mistake — unlimited feedback captures and prevention rules (Free caps at 3 active rules)
- Never re-explain a correction — lesson recall and search across sessions on every agent surface
- See exactly which rule fired — Visual check debugger for every blocked action and the check that fired
- One install, every agent — Auto-connect so supported agents appear automatically after setup (Claude Code, Cursor, Codex, Gemini, Amp, Cline, OpenCode)
- Fine-tune your local model on what your team actually wants — DPO training data export with ready-to-use preference pairs for fine-tuning
- Audit-ready enforcement proof — Personal local dashboard for the individual operator with auditable block history
- Ship hardened agents to production — Model Hardening Advisor plus HuggingFace dataset export
- Hand a PR with proof — Review-ready workflow support and proof-ready lesson bundles a reviewer can verify in 30 seconds
- Hand off without re-onboarding — Team lesson export/import for handoff or migration

What your Pro dashboard looks like
checks: 36 active
feedback: unlimited
exports: DPO + lessons
PAY-NOW PRO
Upgrade to Pro — $19/mo

Billed today · cancel anytime.

Compare plans at a glance
Capability | Free | Pro | Enterprise
--- | --- | --- | ---
Best for | Solo proof that a repeat mistake can be blocked | One operator who wants hosted sync, dashboard proof, and exports | Teams & regulated orgs — one person's correction protects every seat; banking, insurance, healthcare, public sector, audited workflows
Price | $0 | $19/mo or $149/yr | Custom — scoped after intake
Feedback captures | 5/day, 25 total | Unlimited | Unlimited, shared across the org; custom retention and evidence policy
Active prevention rules | 3 active rules | Unlimited personal rules | Shared org rules, policy templates, approvals, and audit export
Dashboard and proof | Local CLI evidence | Personal dashboard, check debugger, DPO/HF exports | Org dashboard, hosted review views, rollout proof, SIEM-ready decision trail and compliance evidence
How to start | `npx thumbgate init` | Self-serve Stripe checkout | Send one repeated workflow failure first — intake before checkout

Free proves the enforcement loop. Pro removes solo limits. Enterprise plans start through intake because shared rules, permissions, rollback paths, and rollout proof must be explicit before checkout.

Enterprise
Engineering teams · Banking · Insurance · Healthcare · Public sector
Shared enforcement for teams & regulated workflows — custom pricing
For teams that need one correction to protect every developer and agent across shared repos, CI, and approval policies — including teams operating under DORA, the EU AI Act, HIPAA, or comparable audit pressure. Pricing is scoped after intake because the buyer needs evidence, deployment boundaries, and approval ownership before checkout.

- Shared lesson database — one hosted, shared lesson DB so one team member's correction becomes every developer's prevention rule across the org
- Org dashboard — active agents, check hit-rates, and risk surfaces across the whole team
- Shared enforcement memory — approval boundaries and rollback safety applied org-wide, not per machine
- Audit-grade decision trail — every PreToolUse evaluation logged with the rule that fired, ready for SIEM export
- Immutable rule provenance — each prevention rule traceable to the feedback event that generated it
- Self-managed deployment — air-gapped or VPC-hosted; no agent state leaves your boundary
- Dialogflow CX fulfillment guard — ThumbGate's pre-action gate sits in front of your Dialogflow CX webhook fulfillment, in your own GCP tenant, so risky or repeat turns are blocked before they touch a database, CRM, or billing system (white-glove design-partner pilot)
- Vertex AI / Gemini scoring, in-tenant — risk and planning scoring runs on Gemini via Vertex (`npx thumbgate setup-vertex`); no conversational data leaves your VPC
- DORA / EU AI Act evidence packaging — machine-readable reports aligned to Article 6, 28, and high-risk provider monitoring obligations
- SSO + role separation — operator, reviewer, and auditor roles enforced at the gate layer
- Enterprise Data Chat — local ThumbGate data Q&A with Dialogflow CX / Vertex-ready governance; live cloud-agent claims require deployment evidence first
- Workflow proof plan included — a scoped review that proves the boundary against one of your real repeated-failure cases before broader rollout
- Quarterly red-team review — prompt-injection and policy-bypass exercises with written findings

Start enterprise intake → Read the build-vs-buy thesis first

Pricing is workflow-scoped and shared after the intake call. Annual pre-pay available.

Enterprise Pilot

## Start the AI Agent Governance Sprint with one repeat failure

This is the fastest path to first paid value for teams. Start with one repo, one workflow owner, and one blocker. The intake is designed to prove that ThumbGate reduces review churn, rollout risk, or repeated agent mistakes before a wider rollout.

### Tell us the workflow. Get a proof plan.

The highest-fit Enterprise buyer is already feeling one repeated failure. Send the workflow first so the next step is scoped around the real blocker instead of a blind checkout.

30-minute intake
Enterprise checkout happens after scope. Send the workflow first. We will qualify the blocker, confirm whether Pro or a scoped Enterprise rollout is the right next step, and keep the purchase path tied to real evidence.
Send workflow first
FAQ

## Common questions

Does ThumbGate support model fine-tuning?
Yes. ThumbGate Pro includes a Model Hardening Advisor and LoRA JSONL export. Pro users can export their episodic memory as DPO (Direct Preference Optimization) pairs to fine-tune local models (like Llama 3 or Mistral) so they natively avoid repeating known mistakes.
How is ThumbGate different from model-training feedback loops?
ThumbGate's intelligence is context, not weights. It doesn't touch the model — it injects past feedback into context so your agent is conditioned by your corrections. Think of it as a behavioral immune system, not a training pipeline. The check blocks are hard enforcement, not soft suggestions.
How is ThumbGate different from persistent agent skills?
Persistent agent skills are reusable instructions. ThumbGate uses the same market shift but adds the missing enforcement loop: lessons become portable skill context, Pre-Action Checks block repeated failures before tool execution, and the dashboard shows evidence for which rule fired and why.
What's the tech stack?
SQLite+FTS5 lesson DB for fast full-text search. MemAlign-inspired dual recall (principle-based rules + episodic context). Thompson Sampling for adaptive check sensitivity per failure domain. LanceDB + Apache Arrow for local vector search with Hugging Face embeddings. ContextFS for context assembly. Bayesian belief updates on each memory. PreToolUse hook enforcement blocks known-bad actions before execution. All local-first — no cloud required.
What AI agents and editors does this work with?
ThumbGate works with Claude Code, Cursor, Codex, Gemini CLI, Amp, Cline, OpenCode, and any other MCP-compatible agent. The Cursor plugin bundle ships in this repo and installs today via `npx thumbgate init --agent cursor`; the Cursor Marketplace listing was submitted 2026-05-19 and is still pending Cursor's manual review, so it is not yet discoverable from the in-app Marketplace. Codex now ships both a standalone plugin bundle and a repo-local app plugin profile, and the published download is linked directly from this page. VS Code works when you run an MCP-compatible agent inside it, but this repo does not ship a standalone VS Code extension today.
Do I have to chat inside the ThumbGate GPT for enforcement?
No. The ThumbGate GPT is the ChatGPT entrypoint for checking proposed actions, capturing thumbs-up/down lessons, and getting setup help. Use it for advice and checkpointing; hard enforcement still runs locally where the agent executes after `npx thumbgate init`.
When should I use Pro versus the Workflow Hardening Sprint?
Start with the setup guide if you only need the local path. Choose Pro after one real blocked repeat when you want your own dashboard, DPO export, and proof-ready exports. Choose the Workflow Hardening Sprint when one workflow owner needs approval boundaries, rollback safety, and rollout proof before wider rollout.
ThumbGate is the control plane, not just a prompt layer. Workflow Sentinel predicts blast radius before execution, and risky local autonomy can be routed into Docker Sandboxes instead of running directly on the host. Team workflows also have a signed hosted sandbox lane for isolated dispatch when local repo access is not required.
How do we trust a new package release?
ThumbGate does not rely on vibes. Release-relevant PRs need a Changeset, SemVer rules keep version bumps honest, sync checks keep manifests aligned, proof lanes run before merge, and the exact main-branch merge commit is verified before the work is called done.
Do I need a cloud account?
No. Free keeps local enforcement on your machine with 5 feedback captures/day, up to 3 active auto-promoted prevention rules, built-in safety checks, and hook blocking. Recall, lesson search, unlimited rules, unlimited captures, and exports open up on Pro. No cloud account is required. The business starts when a team wants shared rules, approval boundaries, hosted review views, org dashboard visibility, and proof that survives handoffs. Pro is the optional solo side lane for a personal dashboard, DPO export, and team lesson export/import — share lessons across projects so one team's mistakes become every team's prevention rules.
What if my thumbs-down is vague?
For the current Claude auto-capture hook, ThumbGate can reuse up to 8 prior recorded entries and the failed tool call for a vague thumbs-down, then keep a linked 60-second feedback session open for later clarification. The timer resets when more context arrives, so the lesson stays attached to one feedback record instead of fragmenting into duplicates.
How are pre-action checks different from prompt rules?
Prompt rules are a starting point, not a finish line. Without prompt evaluation you do not know whether they still hold up under real tool use. ThumbGate adds the human-in-the-loop measurement loop and the enforcement layer: proof lanes, ThumbGate Bench, and self-heal checks show whether behavior improved, and Pre-Action Checks block the action before execution when it did not.
How does ThumbGate fit the agentic development cycle?
Agentic development is not just generation. Teams need Guide, Generate, Verify, and Solve working as a repeatable loop. ThumbGate is the pre-action execution gate in that loop: guidance and feedback become rules, generated tool calls are checked before execution, verification evidence is required for risky actions, and solved failures become reusable prevention gates.
What does Pro cost?
Pro is $19/mo or $149/yr for individual operators and bills immediately through Stripe. Enterprise is custom pricing, scoped after intake, and starts through the workflow intake so scope, shared rules, and rollout proof are explicit before a rollout.
Does ThumbGate support enterprise Google Cloud / Vertex AI?
Yes. `npx thumbgate setup-vertex` detects your active gcloud session, enables the Vertex AI API on your Google Cloud project, and configures secure Application Default Credentials (ADC) so evaluations run within your corporate VPC. For Dialogflow CX, the Enterprise pilot puts ThumbGate's pre-action gate in front of your DFCX webhook fulfillment (deployed in your own tenant) so risky or repeat turns are blocked before they touch a database, CRM, or billing system. It's a white-glove design-partner pilot — ThumbGate gates your own Dialogflow CX agent; it does not host a Dialogflow CX agent for you.
How does ThumbGate contain enterprise API costs?
ThumbGate prevents runaway API costs through a local client-side token ledger (FrontierBudget) that enforces strict cost-containment limits (such as keeping monthly costs under $10/mo). Because GCP billing console alerts are delayed, our local circuit breaker halts runaway agent loops in milliseconds to guarantee budget protection.
Stay Updated

## Get notified when we ship new checks and integrations.

Join the mailing list for new check patterns, agent integration updates, and product news. If you later choose Pro, we keep checkout prefilled on this device.

## Stop the same mistake before it runs again.

Install free. No credit card. No signup. Hit your first check in 60 seconds.

$ npx thumbgate init click to copy
Install Free CLI
Install Claude Extension Upgrade to Pro — $19/mo Start Workflow Hardening Sprint
npx thumbgate init — free CLI, zero friction
$ npx thumbgate init copy
Go Pro — $19/mo