continuous software evolution · self-hosted
aifold is an autonomous AI software factory that connects the dots: it builds, operates, maintains and continuously evolves your software in one unbroken line. Coding agents do the work, code checks each step, and you decide what ships.
Not a one-off generator. A schedule, a merge, a new brief or a change of mind starts the next run: investigated, implemented, checked by code and waiting for your review. Then it does it again.
schedule 07:00 daily opened a work item in aifold
06:59:58 trigger morning-improvement fired · budget $2.00 per phasebrief tighten flaky retry in the ingest tailerEdit src/AiFold.Core/Tailing/Tailer.csgate tests_kept ✓ findings_clear ✓ stays_in_lane ✓lens security · data · deploy · tests reading the diff…
how it works
Traditional development is project-shaped: a kickoff, a delivery, a handover. aifold is persistent. It doesn't turn one idea into one release. It keeps a loop running around your software for as long as the software exists.
A written brief becomes a run: a coding agent in its own git worktree, working through a pipeline of phases, on a budget its CLI enforces.
Your checks run in a sandbox with no network. Gates written in code decide whether a phase passed, not the agent's own opinion. A judge weighs the result before you do.
Every transcript line lands in Postgres and streams live, and every agent's terminal is recorded. Cost, findings and how much of the agent's code survives afterwards are measured, not guessed.
What was learned goes into the knowledge base and into the next brief. Triggers open the next work item. Then it goes round again.
signals
Time, people, merges, tickets, telemetry, dependencies. Each is a trigger: an event source, a condition and an action. All of them run today, switched on per instance; dependency work is still filling out.
Write a brief, pick a pipeline, hand it to an agent. The product evolves with you, not in big-bang projects.
A standing job opens its own work item on a schedule, in your timezone, and has a branch waiting in review.
A signed webhook closes the work item when its branch merges, and survival tracking starts watching the code.
A ticket from GitHub, Linear, Jira or Forgejo becomes a work item, imported by its address or sent by a signed webhook.
An Alertmanager alert opens a work item. An investigating agent reads Prometheus, Loki and Tempo, read-only, and writes a diagnosis it has to back with evidence.
Every change is audited for advisories and no new one gets past the gate. Scheduled maintenance agents upgrade, test and gate like any other change; an advisory mirror of OSV, CISA KEV and EPSS is landing now.
review
Every run stops at review. Read the change, leave notes on the lines they're about, and hand the open ones back to the agent. The same review and the same notes, in the editor you already have open.
The whole change as one diff, with viewed ticks per file and which changed lines your tests actually ran.
An issue, question, nitpick, todo or praise, pinned to the code's text so it stays put when lines move.
Hand the open notes to an agent. It answers or fixes, the checks run again, and you resolve what's settled.
Before it reaches you, four reviewer agents read the change in parallel, for security, data, deploy and tests. A remark has to quote the code it is about, and a grounded issue sends the work back on its own.
quality
The tools your repositories already run report into one place. Findings are fingerprinted and followed across commits, so a change is held to what it added, not to what it inherited.
findings_clear fails a phase on findings its own lines introduced, and files a remark on each one.
A scheduled scan of the default branch, nightly or after a merge, keeps every finding's state and the trend.
Turn one rule's findings into a work item, or one file of it from the review. Suppressing a finding doesn't count as a fix.
Your software is never finished. Neither is aifold.
Agents are fast. What they lack is a place to work: a brief, a budget, a boundary, a record, and someone with taste at the end. aifold is that place, running at machine scale with your taste and your control.
features
Each piece is small and inspectable. Together they turn coding agents from a chat window into a production line you can trust.
From a brief to a change you can run.
Briefs move from draft to ready, running, review and done. Each run gets its own git worktree and flows through agent, check, decision and pause steps, in parallel groups and when: branches, with a cost forecast per revision.
local · container · kata pods
Features, their acceptance criteria and the tests that prove each one, recorded as the work happens. A new criterion that only restates an old one is caught, so the spec stays a by-product of delivery.
criteria_traced · criteria_covered · criteria_judged
Versioned markdown pages with history, diff and restore, tags, a graph view and a search API agents call themselves. Short repository facts are added to every brief automatically.
/api/kb/search · repo_facts
A finished attempt runs on the cluster for eight hours, with its Aspire dashboard. For UI changes the agent records a walkthrough of what changed, shown at review and on the pull request.
flow_shows_change · presentation_grounded
Code decides, before you do.
About forty gates written in code: tests kept, criteria covered, mutants killed, no new advisories, stayed in its lane. Four can never be switched off. A failing gate resumes the same session and says exactly what was wrong.
tests_not_skipped · no_swallowed_errors · findings_clear
Each repository's own validation runs with no network locally, or in a kata pod with a per-step egress allowlist on the cluster. A separate judge weighs surviving mutants. A finished run always stops at review.
podman --network none · kata · egress allowlist
Four reviewer agents read every change in parallel, for security, data, deploy and tests. A remark must quote real evidence, and a grounded issue sends the work back before you see it.
remarks_grounded · findings_grounded
The same pre-tool hooks hold an agent on a cluster pod, a Codex phase or your own machine. Runs that mix untrusted input, private data and outbound access wait for a person, and secrets are redacted before upload.
lethal-trifecta check · redaction
Everything measured, as it happens.
Transcripts land in Postgres and stream as they happen. Every agent runs in a held terminal that is recorded byte for byte; open any one from the live page, search it, replay it, or take the keyboard.
Claude Code · Codex · Copilot · opencode · pi
Every event is priced at the rate in force when it ran, split into input, output and cache. Cost per commit, per thousand surviving lines, the rework tax, and budget windows and caps that stop a run before it overspends.
budgets · caps · forecast
Every file an agent wrote is re-scanned on a schedule. Drift and authored-line survival show how much of its work is still there weeks later, even after the code moved.
no git required
An event source, a condition and an action. Schedules, forge webhooks, Alertmanager and your own app open work; merges close it; release windows merge queued pull requests in order. Fire one now or test a payload.
schedule · webhook · alertmanager · caps
The people who decide what ships.
A 7.5 MB terminal review tool with one continuous diff and vim keys, plus VS Code and Rider extensions that sign in to aifold and put review notes on the lines they are about.
TUI · VS Code · Rider
A product role shapes a brief with an agent on the web, then accepts or sends back a running demo, reset to its demo data, before developers take it on. Design boards attach to the work item.
product role · demo pause
Sign in with OIDC, eight roles from admin to viewer, invitations and step-up with a hardware key. The CLI and editors log in with expiring tokens, and every access, pipeline, trigger and budget change is in the audit log.
aifold login · OIDC · audit log
Bring your own agents, gates and tools.
Plan here, execute there. Agents create work items, read the feature map, start the real application, call its API and drive its UI through two dozen MCP tools and a set of skills.
create_work_item · start_runtime · drive_ui
Signed plugins, pinned by a lock file, add gates, screens and whole agent CLIs. A C# SDK and aifold plugins init get one started.
aifold plugins add · validate · conform
waitlist
aifold is in early access and runs on your own machines. Join the waitlist and we'll invite you as places open, then help you point it at your first repository.