A software factory
your own AI agent drives.
VibeHard gives the AI agent you already use a gated factory. It asks before it guesses, plans before it builds, and runs a 44-gate verification chain before anything is marked done. Version 2.0.3 is out now.
Install the MCP
One command installs the VibeHard MCP server so your AI agent can drive the factory.
curl -fsSL https://vibehard.ai/download/install-agent.sh | bashThe installer registers the server for you, or add this entry to your agent’s MCP config:
{
"mcpServers": {
"vibehard-agent": {
"command": "/Users/you/.local/bin/vibehard-agent",
"args": ["mcp"]
}
}
}Full MCP instructions · For agents · llms.txt · Your first build · What you can build
AI agents: read /llms.txt for install instructions.
How It Fits Together (Illustration)
The deployment protocol.
Custom Software
Gated Custom Software
Your agent writes the code. VibeHard decides whether it is done. Every build runs the full verification chain, and when a check fails the factory hands the failure back to your agent, takes the fix, and re-runs every gate. Nothing is marked as passed until the whole chain is green.
Agentic Workflows
Expert-Skilled Agentic Workflows
Coming soon, in early access. Planned: each workflow is researched from practitioner interviews and published work, then built by the factory as typed, testable steps. Any step that moves money, posts to your books, sends outbound messages or deletes data will wait for a named person to approve it.
Your Machine
Private by Design
The Community Edition runs on your own machine. The factory makes no calls to AI model providers itself: your agent does the reasoning, so your code goes only to the model provider your agent already uses, under your agreement with them. The app also contacts vibehard.ai to check for signed updates. On Linux, generated code is built and tested in a sandbox with no network except for dependency installs; on Mac the sandbox blocks network and limits writes but does not yet isolate reads. If no sandbox is available, the build says so.
The 11-Stage Software
Factory Pipeline.
How VibeHard turns a plain-English request into tested software, with a record at every stage instead of a single unchecked "vibe coding" pass.
- ✕ Guesses ambiguous rules instead of asking
- ✕ Rebuilds components that already exist
- ✕ Grades its own work
- ✓ Questions before plans; protected topics need a human answer
- ✓ Planning documents audited by three review lenses before any code
- ✓ A 44-gate chain, a repair loop, and a separate post-build audit
ACTIVE TRACK: [01] Custom Software Factory — 44 Gates · Slice-by-Slice Build · Repair Loop · Build Audit
Intake & Questions
Your agent hands the factory a plain-English request. Where the request is ambiguous, the factory asks instead of guessing. On the strictest setting, questions about security, data, who can access what, payments or compliance must be answered by a person, not the agent.
Reference Analysis
Point the factory at a product you want to match or replace. It records each reference capability and decides what to keep at parity, modernize, improve or drop, so nothing is lost by accident.
Buy Before Build
Before any custom code is planned, the factory looks for proven components that already do the job, and records each buy-or-build decision. A later gate checks that the build honored those decisions.
The Planning Documents
Writes the spec, product requirements (PRD.md), system requirements (SRS.md), system architecture (SAD.md), architecture decision records, assumptions, a red-team brief and a build plan.
Planning Audit
Three independent review lenses (skeptic, architect and minimalist) audit the plan before a line of code is written. Findings go back into the plan.
Your Sign-Off
Scope review and plan approval are recorded checkpoints. The build waits for your answer, and a changed plan comes back to you for approval.
Plan Seal
The approved plan is sealed: a SHA-256 digest of the planning documents and the starting code tree, recorded before any code is written.
Slice-by-Slice Build
Your agent writes the code one slice at a time, from work orders the factory issues and checks. Backends for TypeScript, Go, Rust, Python and Elixir; the 2.0.3 acceptance run exercised TypeScript.
Repair Loop
When a check fails, the factory sends your agent the full failure output (both output streams, new in 2.0.3), takes the fix and runs the checks again, up to ten attempts.
The 44-Gate Chain
Security, quality, contract and operations gates, fitted to the project: a gate that does not apply reports n/a instead of a fake pass. Only a full pass writes the sealed pass marker.
Build Audit & Handoff
The same three lenses audit what was actually built. The factory writes an as-built report, updates the README and architecture docs, and hands the finished project to you.
The 44-Gate Verification Chain
Fixed, rule-based checks for security, quality and operations, plus a completeness review. See every gate.
Sealed Pass Marker
Written only when the chain passes, and bound to the project files and to the exact set of gates that ran, so a partial run cannot pass as a full one.
Completeness
A reviewer compares the finished features against the spec. A missing feature blocks, so “passed” means built, not just compiled.
Secrets & Static Analysis
Scans for leaked secrets, risky code patterns and dependencies with known vulnerabilities. A leaked secret always blocks.
Fitted to the Project
Gates that do not apply report n/a instead of a fake pass, and a passing chain needs at least one substantive gate to have done real work.
Gated
Repair
Loop
When a check fails, the factory does not just stop. It hands your agent the failure, takes the fix, and re-runs every gate. A fix counts only when the whole chain passes. Production repair for hosted workflows is coming soon, and a person will approve every fix.
The VibeHard
Architecture.
Your Own Agent
Works with the AI agent you already use, over MCP, the standard way AI agents connect to tools. Your agent does the writing; VibeHard issues the work orders and checks every result.
Snapshots & Rollback
A snapshot before every build and after each successful repair. Roll back to a snapshot with one call.
Human Checkpoints
Scope review and plan approval are recorded with their answers. On the strictest setting, sensitive questions must be answered by a person.
Signed Updates
Releases are signed. The updater checks for a new release every 30 minutes, verifies the signature before installing, and refuses downgrades.
Access the Engine.
The Community Edition is available now. Paid tiers open in phases. What each tier includes.
Community Edition
- — Self-hosted: the factory runs on your Mac or Linux machine.
- — The full 44-gate verification chain.
- — Free for personal use. Commercial use needs the commercial-use license, which comes with the Software Factory plan ($199/mo).
- — Hosted app connections, metered, with a free monthly allowance (coming soon).
Software Factory
- — Everything in Community, plus the commercial-use license.
- — The full 44-gate verification chain.
- — Factory runs hosted by us (coming soon).
- — Commercial license: on sale now.
Agentic Workflows
- — 3-agent minimum ($1,497/mo starting).
- — Includes $100/mo of model credit for the whole package, not per agent.
- — Approval holds: steps that move money, post to your books, send outbound messages or delete data wait for a named person (coming soon).
- — A dedicated hardware-encrypted, attested enclave after our pilot (coming soon).
- — Early access: by application, not on sale yet.
Enterprise Setup
- — Your own gates for your own policies, added to the chain.
- — Hands-on scoping and rollout support.
- — Custom gates are checks, not certifications. We are not SOC 2 audited.
- — Starts with a consultation; not sold self-serve.