YYLO

Introduction

YYLO coordinates coding agents from engineering intent through validated code, preserving durable evidence of every task, session, review, and evaluation. As AI-generated code becomes standard, teams need to understand how coding agents worked, what decisions they made, and whether the validated code matches the original goal. YYLO turns agent work into inspectable engineering records. Managing coding agents with clear evidence is essential, and YYLO gives teams a structured way to oversee coding agents from start to finish, building confidence in automated development and supporting agentic engineering with accountability.

---

What is YYLO?

YYLO (pronounced "why-lo") is an open-source system of work built for agentic engineering. It coordinates coding agents from intent to validated code, making the entire process inspectable and reviewable. The tool records task definitions, session provenance, review evidence, and evaluation results inside Git, so teams can see exactly what happened and why.

The core problem YYLO solves is accountability. Many teams use coding agents to generate code, but the output often arrives without context or proof of correctness, and they have no easy way to audit what those coding agents produced. YYLO fixes this by binding each task to one bounded outcome, routing work to a specific coding agent, validating results with tests and policy-bound review, and storing durable receipts in Git.

Agentic engineering is rapidly becoming a standard workflow. As organizations delegate more work to AI, they need control loops that keep coding agents aligned with product goals. YYLO does not replace Git or your repository workflow; it coordinates agent execution and makes the work that produces code inspectable. Above all, agentic engineering requires tools that provide structure, evidence, and control—exactly what YYLO delivers.

Key Features of YYLO

YYLO's key features focus on making coding agents transparent, controllable, and verifiable within an agentic engineering system.

Define Intent Explicitly

Each task in YYLO records one bounded outcome, its constraints, and its dependencies. This gives coding agents clear boundaries before any execution starts and prevents scope creep.

Delegate Execution with Provenance

YYLO routes work to a selected coding agent and preserves the worktree, model, and session provenance. Teams can trace exactly which agent did what, with which model, and in which session.

Validate Results with Evidence

Tests, evidence receipts, and policy-bound review make acceptance inspectable. Instead of trusting output blindly, teams verify that validated code meets the original task requirements.

Record Everything in Git

Task responses, commits, review evidence, and merge outcomes remain durable in Git through the Ledger layer. This makes each change reviewable and creates a reliable engineering memory for future work with coding agents.

Manage Task Dependencies

YYLO tracks task truth and dependencies in Git, helping teams coordinate coding agents without duplicating effort or losing context across sessions.

Compare Agent Attempts

With retained benchmark evidence, teams can compare how different coding agents handled the same task. This supports better agentic engineering decisions about which agent or model to use.

Use Cases for YYLO

Controlled AI Code Changes

A team wants to add keyboard navigation to an application. They define one bounded task in YYLO, delegate execution to a coding agent, and validate the result with tests before merging. The entire process is recorded as evidence.

Multi-Agent Workflow Management

When several coding agents work on the same repository simultaneously, YYLO isolates worktrees and preserves session provenance. This prevents conflicts and keeps each coding agent's contribution clear.

Building Engineering Memory

Teams use YYLO to accumulate task, session, and evaluation evidence over time. This turns scattered AI work into a durable engineering record that supports future agentic engineering decisions. It also helps teams understand which coding agents perform well over the long run.

Reproducible Agent Evaluations

Teams can compare coding agents against benchmark cases to see which agent produces the most reliable code. YYLO Benchmark isolates runs and preserves evaluation evidence for later review.

How to Use YYLO

Using YYLO to coordinate coding agents starts with a single change:

1. Install the CLI globally: npm install -g @yylo/[email protected]
2. Initialize a bounded task: yy init --task "Add keyboard navigation" --subagent piintent
3. Let the coding agent execute in an isolated worktree with session provenance.
4. Validate the result using tests and review evidence.
5. Inspect what happened through preserved task, session, and commit records.

This simple loop gives teams a repeatable way to coordinate coding agents while keeping every step documented. The goal is to make coding agents productive and accountable, not just fast. It is a practical starting point for any team exploring agentic engineering for the first time.

Target Audience for YYLO

• Engineering teams that use coding agents in production and need accountability
• Tech leads who want reviewable AI-generated code from coding agents
• DevOps teams looking for structured agentic engineering workflows
• Quality engineers who want to verify coding agents' output
• Open-source contributors who want transparent agent processes
• Startups building AI-assisted development pipelines

Is YYLO Free?

YYLO is open source. The current release is version 0.2.1-rc.1 and is available through npm under the @yylo scope. Teams can install and use YYLO to coordinate coding agents without licensing fees. Since the project is still in an early release-candidate phase, users should check https://yylo.dev for updates, documentation, and any future pricing changes. Because it supports agentic engineering at no cost, YYLO is attractive for teams experimenting with AI-driven development.

YYLO's Pros and Cons

Frequently Asked Questions about YYLO

What exactly does YYLO do?

YYLO coordinates coding agents from task definition through validated code. It captures task responses, session provenance, review outcomes, and commit evidence to make agent work fully inspectable within an agentic engineering workflow.

Does YYLO replace Git?

No. YYLO works with Git and stores task truth, dependencies, reviews, and merge evidence directly in the repository. It complements Git workflows instead of replacing them, giving coding agents structure inside existing Git practices.

Is YYLO production-ready?

The current version, 0.2.1-rc.1, is a release candidate. It is available for real use, but teams should evaluate features and expect ongoing improvements. Early adopters of agentic engineering tools should monitor the official changelog.

How does YYLO validate agent work?

YYLO uses tests, evidence receipts, and policy-bound review to validate coding agents' output. Acceptance becomes inspectable because validation steps are recorded alongside the candidate code.

Can YYLO work with different agents and models?

YYLO is designed to delegate bounded work across agents and models. It preserves the worktree, model, and session provenance for each run, so teams can compare coding agents fairly. Specific provider integrations should be checked in the official documentation.

What is an Engineering Change in YYLO?

An Engineering Change is the strategic record YYLO is building to link intent, decisions, attempts, validated code, and eventually real-world outcomes. This will help teams reason about coding agents at a higher level of abstraction. It is a product direction, not a claim about the current release.

YYLO Tags

coding agents, agentic engineering, open source system, coordinate coding agents, validated code, session provenance, AI engineering workflow, agent coordination tool, task evidence, YYLO CLI, engineering memory, developer tools