Consequence-governance infrastructure · local-first · human authority at every boundary
AI agents optimize for task completion.
FoldEngine governs whether work is allowed to become real.
FoldEngine understands repositories, constructs implementation plans, generates governed engineering candidates, validates work, preserves evidence, and improves through consequence memory — without autonomous execution or hidden approval.
Receipt. Evidence. Uncertainty. Next step.
FoldEngine prepares candidates, evidence, and review surfaces. Humans still authorize apply, commit, push, merge, deploy, release, and publication.
Where to begin
Entry diagnostic online, governed execution offline, and operations surfaces to manage work across projects — same governance logic, different depth.
Trial Probe
Hosted entry diagnostic. Submit a repo or project for a fast bounded report and a proceed/hold/block decision receipt with a recommended next step.
FoldEngine Runtime
Offline operating environment for governed work. Guided deployment for teams that need isolated workcells, preserved evidence, formal review, and human-controlled delivery boundaries — without mutating source or granting execution authority.
Operations surfaces
Organization Operations Center and Project Workspace. Manage governed work across projects — review queues, evidence activity, blocked work, and environment readiness — without autonomous portfolio automation.
Trial Probe is the fastest bounded diagnostic. FoldEngine Runtime is the offline operating environment for consequential work. Operations surfaces help teams monitor projects, review load, and readiness inside the same governed runtime. See FoldEngine Runtime.
Flagship walkthrough
Follow one realistic first-month customer journey from mounted repository through construction, governed engineering, development packaging, validation, evidence, and review handoff.
Open the walkthrough →FoldEngine Runtime
Customer tasks map to governed surfaces inside the offline operating environment.
Start a new project
New Project Guided Intake — shape requirements and hand off to construction.
Take over an existing repository
Repository Takeover Wizard — observe, test, and classify the next safe move.
Review construction package
Construction Workspace — inspect bounded build artifacts before review.
Trial bounded work
Workcell Run Detail — read-only evidence for a governed run.
Make a formal review decision
Formal Review Decision — human review before the next boundary.
Inspect evidence and receipts
Evidence-backed workspaces with receipt summaries and inspectable proof.
Monitor projects and readiness
Organization Operations Center, Project Workspace, and Environment Readiness.
What the runtime actually does
These are the four questions the product now answers directly for a buyer or evaluator.
1. What is FoldEngine?
A governed engineering runtime that understands repositories, shapes construction packages, generates governed candidates, validates bounded work, preserves evidence, and keeps human authority visible at every delivery boundary.
2. Who is it for?
3. What problems does it solve?
4. What does the customer receive?
Capability overview
The homepage should answer what FoldEngine is and what happens in a real first month. Architecture, subsystem detail, and implementation depth live on the dedicated pages below.
Customer and repository readiness
Customer readiness, environment posture, repository discovery, stack detection, toolchain gates, version checks, and repository conventions determine whether the next move is admissible.
Construction Workspace
Requirements, dependencies, acceptance, and projection become a bounded construction package before engineering work begins.
Governed engineering and development
Candidate work, validation plans, documentation updates, release notes, evidence plans, and review packages are prepared without widening authority.
Consequence Intelligence
Transition records, kernel discovery, kernel recall, organization memory, and recommendations improve future work while keeping evidence, review, and human apply as the final boundary.
Supported stacks
FoldEngine should explain current support honestly rather than implying universal autonomous repair.
Current supported or governed stacks
Python · Node · TypeScript · Go · Rust · Java · .NET · Ruby · PHP · Shell · C/C++ · SQL governed paths
Planned / explicitly not current
COBOL · Swift · Kotlin · Scala · Elixir are roadmap items only. They are not current product claims.
Adaptive governance
Not every task deserves the same depth of intelligence and assurance.
Before running, FoldEngine asks:
Then it recommends a governed path:
Same governed workcell across all paths. Same operator authority at the consequence boundary. Same receipt format. Same consequence memory.
Project context comes first
Runtime does not simply point at a repo.
It first captures the project context: project type · source boundary · privacy posture · risk level · available models · operator preferences · prior consequence history.
That context becomes the strategy input. The strategy advisory recommends intensity. The governed workcell executes only within the allowed boundary.
How work arrives
Bounded by evidence. Private by default. Recoverable across runs.
Submit a repo or project for a hosted bounded diagnostic. FoldEngine checks evidence, identifies the failure shape, and returns a proceed/hold/block decision receipt with a recommended next step.
Bring a stuck local or offline project to FoldEngine Runtime. It captures project context, recommends the right governance intensity, coordinates bounded intelligence roles, runs candidate work only through the governed workcell, preserves evidence, and builds consequence memory — without mutating source or granting execution authority.
| You bring | FoldEngine does |
|---|---|
| AI agent proposal | Classifies, gates, receipts |
| Software change | Bounds, trials, routes |
| Research claim | Evidence-checks, gaps, bounds |
| Stuck project | Snapshots, classifies, recovers |
| Operational decision | Reviews, receipts, remembers |
| Robot advisory plan | Projects, advises, gates |
Closed-loop governance
Agents optimize for task completion. FoldEngine optimizes for governed consequence.
Local intelligence is role-governed, not agentic. LLMs suggest. Decomposers sense. Critics review. Security roles flag risk. The governed workcell executes. The operator authorizes irreversible action.
Strategy recommends. Workcell executes. Operator authorizes. Evidence preserves. Memory derives.
Does not execute.In the offline governance runtime, this pattern is used across local runtime health, node/model roles, local surfaces, folders, services, repository state, pull-request metadata, CI/CD gate metadata, ticket/workflow metadata, security findings, compliance/export requests, and the relationships between them.
Observe / diagnosis
FoldEngine identifies the risky seam before it turns into a real consequence.
Classify / gate
It checks the evidence, names what is missing, and shows whether the next move is ready, risky, or blocked.
Candidate / receipt
The proposed next step becomes a reviewable record, with evidence, uncertainty, and the reason it was held or advanced.
Review / continuity / next run
Review, continuity, and the next move stay visible, while execution authority stays with the operator.
Trial Probe is the fastest way to understand a project in its current state. FoldEngine Runtime is the deeper offline environment for teams that need evidence, review, continuity, and careful control before work crosses into the real world.
Runtime preview
Explore three public demonstrations: the Runtime Preview, the Physical Consequence Simulator, and the Evidence & Memory Explainer.
See how FoldEngine approaches stuck-project recovery, new-project intake, and consequence memory in a guided public preview.
Open Runtime Preview →See how a proposed action is checked before it is allowed to become a real-world consequence.
Open simulator →See how receipts, lineage, and memory stay connected without taking authority away from current evidence or human review.
Open explainer →Public demonstrations only. No live repo access, no source mutation, and no autonomous execution.
Works with your toolchain
| Tooling | Good at | FoldEngine adds |
|---|---|---|
| AI coding agents & IDE review | Speed, suggestions, day-to-day coding flow | False-closure check before build-on, demo, ship, or handoff decisions — with governed delivery |
| RAG / ask-my-repo | Exploratory Q&A from retrieved context | Bounded verdict — supported findings, evidence gaps, boundary notes, named next move |
| MCP & connected tooling | Evidence access across systems | Governance — which question to ask, which claims are allowed, what history to preserve |
| SAST & dependency scanners | Continuous signals, CVEs, policy checks | Decision framing for a specific moment plus ledger continuity across repeated reviews |
Use your everyday AI stack for velocity. Use FoldEngine when the decision is weight-bearing.
Trial Probe is the fast online entry point. FoldEngine Runtime is the deeper offline environment for teams that need reviewable work, preserved evidence, and careful control before delivery consequences become real.
Already assigned? Sign in to the client portal to view current project status.
Trial Probe is the fast online entry point. It gives you a clear view of what the evidence supports and what should happen next. FoldEngine Runtime is the deeper offline environment for teams that need context-aware review, isolated work, preserved evidence, and careful control before change crosses a real delivery boundary.
It takes in project context, recommends the right level of review, runs work inside a contained environment, and preserves the evidence trail around what happened. It does not commit, push, merge, deploy, or release on its own. Human authority remains in place at every consequential boundary.
Most AI review tools help you move faster inside the workflow you already have. FoldEngine helps you decide whether important work is actually ready to move forward, with evidence, review, and a preserved record of what was decided.
No. FoldEngine does not mutate source, commit, push, merge, deploy, or release anything. Providers do not hold authority. No memory-based authority override. The operator remains in authority at every consequence crossing. FoldEngine governs consequence — it does not execute autonomously.
