YYLO

What is YYLO?

YYLO (pronounced why-lo) is an open-source system of work and agentic engineering platform designed to coordinate AI-powered coding agents. It guides engineering projects from initial intent all the way to delivering validated, production-ready code. Crucially, YYLO preserves the entire "engineering memory"—documenting the task definition, session details, code reviews, and evaluation evidence that explain exactly how and why changes were made. This ensures teams not only run automated work but fully understand the decision-making and outcomes behind every piece of generated code.

Key Features of YYLO

From Intent to Code with Full Traceability: YYLO captures the complete lifecycle of engineering tasks. Every action, from task creation and agent delegation to validation, review, and merging, is logged and linked, creating an auditable trail of work.

Preserves Engineering Memory: Unlike isolated automation scripts, YYLO maintains persistent evidence. This includes the original task intent, constraints, agent worktrees, model provenance, test results, review comments, and final commit artifacts, making the "why" behind code changes permanently inspectable.

Coordinates Multi-Agent Workflows: The platform acts as a control plane, routing bounded pieces of work to specialized AI agents (like the integrated pi subagent) and models. It manages dependencies and executes work in isolated environments to ensure clean, reproducible results.

Integrates with Existing Git Workflow: YYLO does not replace your version control system. It enhances it by adding structured task management and evidence logging directly into your Git repository, making agentic work a first-class, traceable part of your engineering process.

Enables Validation and Review: Built-in mechanisms for testing, policy-bound reviews, and evidence receipts ensure that agent-generated code meets quality standards before being integrated. Teams can confidently accept or reject proposed changes based on concrete, retained evidence.

How to Use YYLO?

Using YYLO involves installing its command-line interface and integrating it into your development workflow to manage agentic tasks.

1. Installation: Begin by installing the YYLO CLI globally via npm.

   npm install -g @yylo/[email protected]
   

2. Initialize a Task: Define a bounded engineering outcome. For example, to add keyboard navigation to a project using the pi agent, you would run:

   yy init --task "Add keyboard navigation" --subagent pi
   

   This creates a task record with explicit intent and constraints in your Git repository.

3. Delegate and Execute: Start the coordinated work. YYLO will route the task to the specified agent, which will operate in an isolated worktree. You can monitor and manage execution:

   yy start -s pi -i 1
   

4. Validate and Review: Once the agent proposes code, YYLO helps you validate it through tests and structured review processes. The evidence from this stage—tests, review comments, receipts—is preserved alongside the task.

5. Record and Merge: Accepted changes are committed with their full provenance. All artifacts—task responses, commits, and review evidence—are logged into the YYLO Ledger within Git, creating a durable record of "what happened" for future reference and learning.

Price and Licensing

YYLO is a fully ### open-source platform. The core software, including the YYLO control plane, the Ledger, and Benchmark components, is freely available under an open-source license. You can install, use, and modify it without any subscription fees. The project is hosted on GitHub, and contributions are welcome. There is no vendor lock-in; you retain full control over your engineering memory and workflow.

Helpful Tips for Maximizing YYLO

• Start Small: Begin with a single, verifiable change to understand the workflow. Use the example yy init --task "Ship one verified change" --subagent pi to get familiar with the process.

• Leverage the Ledger: Treat the YYLO Ledger as your source of truth for agentic work. It turns your Git repository into a queryable database of engineering intent and outcome.

• Define Clear, Bounded Tasks: The system works best with well-scoped tasks. Clear intent and constraints guide agents more effectively and produce more focused, reviewable results.

• Use Benchmark for Evaluation: As you scale, use the YYLO Benchmark component to create immutable test cases, compare different agent attempts, and build a body of evaluation evidence to guide future agent selection and tuning.

• Inspect the Evidence: Always review the preserved session provenance, worktree, and validation receipts. This "engineering memory" is key to debugging, improving processes, and building trust in automated workflows.

Frequently Asked Questions (FAQs)

What problem does YYLO solve?

YYLO addresses the "black box" problem in AI-powered coding. While agents can generate code, they often lack transparency. YYLO ensures every step—from the initial task request to the final merged code—is documented, validated, and preserved, making agentic engineering auditable and trustworthy.

Does YYLO replace Git or CI/CD tools?

No. YYLO is a coordination layer that works with your existing tools. It uses Git as the durable store for task truth (the Ledger) and integrates validation steps that complement your CI/CD pipeline. It coordinates the work that produces code, which is then managed via your standard Git workflow.

Can I use my own AI models or agents with YYLO?

Yes. The architecture is designed to be extensible. While it comes with integrated subagents like pi, the platform is built to delegate work across different agents and AI models, allowing you to plug in specialized tools as needed.

What is an "Engineering Change" and how is it preserved?

An "Engineering Change" is YYLO's strategic record that links high-level intent, execution decisions, agent attempts, validated code, and outcomes. It's preserved across the system's three layers: the YYLO control plane coordinates the action, the Ledger stores task truth in Git, and Benchmark retains evaluation evidence, together forming a connected memory.

Is my code or data used for training?

As an open-source platform you host and control, YYLO does not send your code, task data, or engineering memory to external servers for training purposes. Your evidence and workflow data remain within your own version-controlled repository and infrastructure.