Gatekeeper

Company: Gatekeeper

Self-reported basis: The description is entirely self-reported by the author and unverified.

Commercial due-diligence read: Gatekeeper appears to be a local-first, deterministic code-review tool that uses AI for evidence gathering but retains human or policy authority for final decisions. It positions itself as an accountable alternative to opaque AI review systems, with a focus on project memory, inspectable verdicts and bounded AI interaction. The single most important open question is whether the author’s claims about determinism, evidence preservation and local-first operation are substantiated by actual functionality or merely conceptual design.

The description states that Gatekeeper is a local-first, evidence-first repository review tool. It reviews changes against deterministic policy and returns inspectable verdicts such as BLOCK, REQUIRE_CHANGES, ESCALATE, or FAST_PATH. It includes features like:

• Project Memory (bounded local storage of evidence)
• Evidence timeline
• Historical commit review
• Pull Request Explorer

It uses Codex with GPT-5.6 to assist in retrieving and explaining bounded evidence, but the final verdict is made by Gatekeeper itself.

The system is built as a TypeScript monorepo, using Node.js, React, SQLite, and Git. It is designed for local operation only, without GitHub write actions or hosted backend requirements.

Inference: The product is described as a developer tool focused on code review workflows, with an emphasis on accountability and determinism in decision-making.

The author states that Gatekeeper was built to address the lack of accountability in current software review practices. It aims to be more accountable than typical AI tools by:

• Preserving evidence behind each decision
• Returning deterministic verdicts instead of opaque scores
• Ensuring that repository text is treated as untrusted evidence, not instructions

It positions itself as a tool that helps developers understand context without allowing AI to silently become the authority.

Inference: The positioning evolved from a desire to improve code review accountability to a system where AI supports but does not replace deterministic policy. This reflects a shift toward trustworthy AI-assisted tools with clear boundaries.

The description states that Gatekeeper is built for developers, particularly those working in teams that rely on pull requests and repository change reviews.

It targets users who value:

• Accountability
• Inspectable decisions
• Historical context
• Deterministic policy enforcement

Inference: The target customer is likely a developer or engineering team looking to improve code review rigor, especially in environments where context loss leads to repeated debates or mistakes.

Not evidenced.

The description does not mention any pricing model, monetization strategy, or business model. There is no indication of whether this will be offered as a freemium, SaaS, open-source, or other type of product.

The project is built with:

• Node.js and TypeScript for backend logic
• React and Vite for the dashboard UI
• SQLite for local storage of Project Memory and evidence
• Git and GitHub CLI for repository access
• Codex with GPT-5.6 used in development (not integrated into runtime)

It is a local-first system, meaning:

• No hosted backend
• No GitHub write actions
• One fixed repository per session
• Explicit sync actions, not background polling

The architecture is described as narrow and intentional, avoiding complexity.

Inference: The technical approach suggests a focus on security, control, and reproducibility, with an emphasis on local operation and bounded AI use.

Not evidenced.

There is no mention of users, customers, revenue, or adoption. The project is described as a hackathon submission (Devpost entry for OpenAI 2026 hackathon), implying it’s early-stage and not yet in production.

Not evidenced.

The description does not reference competitors or market positioning beyond general claims about accountability vs. opaque AI tools.

• Unverified claims: The author states that the system preserves evidence, enforces determinism, and prevents prompt injection — but no demonstration or testing of these features is provided.
• Local-first design may limit scalability: The lack of a hosted backend could hinder adoption in larger teams or enterprise settings.
• No pricing or monetization strategy: No indication of how this will be commercialized.
• Single-person team: A team size of one raises questions about development capacity, long-term maintenance, and product maturity.
• Use of Codex during development but unclear runtime integration: The author says Codex was used for design and implementation, but it’s unclear if it's part of the final product or just a development aid.

1. Can you demonstrate how the deterministic policy is enforced in practice?
2. How does Gatekeeper distinguish between trusted and untrusted repository input without allowing prompt injection?
3. What are the actual use cases where this tool would be more valuable than existing code review tools?
4. Is there any testing or validation of the local-first architecture under real-world conditions (e.g., interrupted runs, stale state)?
5. How is Project Memory managed and updated? Is it manually curated or automatically populated?
6. What are your plans for scaling beyond a single developer or small team?