English · Italiano
Your agents write the code. Wayloop runs the project around it —
from idea to merged code, in your issues, with humans at the gates.
Documentation · How the loop works · Architecture · Roadmap · Contributing
Status: pre-alpha. There is no release yet. The design is recorded in the architecture decisions and the specifications; what comes next is in the roadmap.
Coding agents now write code quickly. Projects still fail in the work around the code: intent that was never written down, plans that drift away from what is actually built, sessions that cannot be resumed by the next agent, and costs that nobody measures.
Two families of tools address half of the problem each.
- Spec-driven tools capture intent before code is written, but stop at the plan file.
- Agentic loops keep an agent working until a goal is met, but do not know the plan of the project they are working on.
Wayloop is designed to join the two at the scale of a whole project: a deterministic engine runs the loop, the plan lives in your issue tracker, and people decide at the gates. The loop has four movements: decompose an idea or an existing codebase into milestones, epics, stories, specifications and issues; execute every issue through the same cycle; reconcile every event into a proposed change to the plan; re-plan once a person approves it. The design is described in How the loop works.
Wayloop has no release yet, so there is nothing to install; the work towards the first release is in the roadmap.
Not available yet: there is no release to run; see the roadmap.
Not available yet: the engine exposes no tools to agents; see the roadmap.
No command is released yet. A build from source answers wayloop version and wayloop steps
(reference); the commands of the loop are in
the roadmap.
One engine decides; thin adapters translate. The engine never calls a model, and agents never write the state by hand (ADR 0001).
| Part | Path | What it does today |
|---|---|---|
| Core | crates/wayloop-core |
Rust library with no I/O. It fixes the vocabulary of the issue cycle: nine steps in order, their stable identifiers, and which step is an approval state. |
| Command line | crates/wayloop-cli |
The wayloop binary, an adapter only: it parses arguments, calls the core and prints JSON. |
| Agent content | .agents/ |
Roles and skills in the open Agent Skills format, with generated mirrors for Claude Code. They are used to build Wayloop itself. |
| Process | roadmap/, specs/, sprints/, scripts/ |
The plan as code, synchronised with the GitHub issues; specifications with numbered requirements; sprint lanes of disjoint paths; the checks run by CI. |
Details in Architecture.
These rules bind every part of Wayloop. They come from the constitution and the architecture decisions, and a change to any of them needs a new ADR and the maintainer's approval.
- Deterministic decisions. All decision logic lives in the core. The same state and the same event always produce the same next state. A model never declares its own work finished: a deterministic check does.
- JSON contracts. Every input and output crossing the engine boundary is JSON with a versioned schema; a breaking change is a new version, never an edit of the old one. One envelope for every command, with stable error codes and exit codes, is set out in ADR 0009.
- Gates. Approval states cannot be passed by the loop: the council report, the roadmap,
an approved specification, a merge. Agents ask questions on the issue, in a fixed format.
In the core today,
mergeis the approval step of the issue cycle. - Ledger. The ledger is append-only and hash-chained, and written only by the engine. The state is a function of the ledger and is tested by replay. Model output enters the state only after schema validation.
- The tracker is the database. The plan lives in the issues, the specifications in the repository. A project stays readable without Wayloop.
- Cost is measured. Every phase has a token budget. No embeddings and no vector store (ADR 0004).
The status of each decision is in the ADR index.
Wayloop is built with the process it describes. Every change starts from an issue in the
roadmap; behaviour of the engine starts from a specification with
numbered requirements (specs/); structural choices start from an ADR.
Agents and people follow the same rules (AGENTS.md), and CI checks the plan, the
conventions, the house style and the documentation on every pull request.
- Start with CONTRIBUTING.md.
- The documentation is published in English and
Italian, rebuilt on every change to
main. Agents can readllms.txt.