hardno-engine

Company: hardno-engine

Self-reported basis: The entire analysis is based on a single project description submitted by the author to the OpenAI 2026 hackathon on Devpost. No external verification, revenue, customer data or traction evidence is available.

What it appears to be: A local runtime guardrail tool designed to block risky AI-agent actions before execution and record explainable receipts. It operates as a policy firewall for AI coding agents, using a Go binary with YAML policy layers and JSONL trace logging.

What changed: The author submitted this project as part of a hackathon, indicating an early-stage development effort. No prior version or evolution is described.

Single most important open question: Is there any evidence that this tool has been used in real-world developer environments or integrated into existing workflows?

The description states that hardno-engine is a local guardrail runtime that blocks risky AI-agent actions before execution and records explainable local receipts. It functions as a policy firewall for AI coding agents, particularly targeting tools like Codex.

It includes:

• Project, user, and built-in YAML policy layers
• First-match rule evaluation
• JSONL traces with a SQLite index
• Log, explain, and scoped allow commands
• Deterministic prompt-injection heuristics
• A dependency-free hook-protocol adapter

The tool is implemented as a single static Go binary with two frontends:

• PATH shims
• A JSON hook adapter

It was built using Codex and GPT-5.6, and the author claims to have used Codex for architecture decisions, implementation, debugging, CLI design, documentation, and release preparation.

Inference: The tool is a developer-facing utility designed to enforce safety policies in AI-assisted coding workflows, with an emphasis on local execution and traceability.

The author states that the inspiration came from a desire to keep safety policy ownership with the developer and project, rather than with the agent itself. This suggests a positioning around developer autonomy and control over AI agent behavior.

The product is described as:

• A local policy firewall
• Designed to block dangerous actions before execution
• To record explainable receipts

There is no evidence of prior versions, market positioning or competitor comparisons in the description.

Inference: The tool positions itself as a developer-centric safety layer, not a commercial product. It is a proof-of-concept or hackathon submission, not a mature product with a defined market.

The author describes hardno-engine as a local guardrail runtime for AI coding agents. The primary use case involves developers using tools like Codex, where the tool acts as a policy enforcement layer.

It is built to be used in developer environments, with support for:

• PATH shims
• JSON hook adapter

There is no mention of enterprise customers, specific developer personas, or segmentation beyond "developers using AI agents."

Inference: The target customer is likely individual developers or small teams working with AI coding tools. No evidence of a defined ICP (Ideal Customer Profile) exists.

The description does not contain any information about:

• Revenue model
• Pricing structure
• Monetization strategy
• Paid features or tiers

It is presented as a single static binary with no indication of commercial licensing, subscriptions, or paid access.

Inference: No business model or pricing evidence is provided. The tool appears to be an open-source or prototype effort.

The author states:

• Built with Go, Codex, and GPT-5.6
• Uses YAML policy layers, JSONL traces, and SQLite index
• Implements a dependency-free hook-protocol adapter
• Includes table-driven policy tests, scripted wrapped-shell sessions, golden JSON fixtures, race detection, and failure-mode tests

It is a single static binary with two frontends (PATH shims and JSON hook adapter).

Inference: The tool is technically well-thought-out for a prototype, with attention to testing, observability, and modularity. However, it is not yet a production-grade product.

The project is described as:

• A hackathon submission
• Released as v0.1.0
• Built during Build Week
• Repository: https://github.com/ndstab/hardno-engine
• Release: https://github.com/ndstab/hardno-engine/releases/tag/v0.1.0

There is no evidence of:

• Customers
• Usage metrics
• Adoption
• Product-market fit
• Revenue or funding

Inference: The tool is in a very early stage, likely a prototype or proof-of-concept, with no traction or maturity signals.

The description does not mention any competitors or direct market context. It is not clear whether similar tools exist in the market for AI agent safety or policy enforcement.

Inference: No competitive landscape is described. The tool may be unique or early in a niche space, but this cannot be confirmed without external data.

• No traction or adoption evidence: The project is presented as a hackathon submission with no real-world usage.
• Unproven commercial viability: No business model, pricing, or monetization strategy is evident.
• Single-person team: Only one developer is listed, which may limit scalability and product development velocity.
• Prototype nature: The tool is described as v0.1.0, suggesting it is not yet mature for production use.
• No external validation or testing: All evidence is self-reported.

Inference: The tool is a conceptual prototype, not a commercial product. It may be useful in early-stage experimentation but lacks any signs of real-world utility or scalability.

1. What specific AI coding agents does hardno-engine currently support, and how are they integrated?
2. How is the policy enforcement boundary defined, and what are the known limitations of interception?
3. Has the tool been tested in real-world developer workflows or environments?
4. Are there any plans to expand beyond local execution or support for other platforms (e.g., Windows)?
5. What is the intended path from prototype to commercial product, if any?