# YOLO Mode

YOLO mode controls how much autonomy agents have during workflow execution. When enabled, agents work without asking for validation at each step — like a senior team that you trust to get things done.

## Three levels of autonomy

| Level      | Activation                          | Stops for                                             | Best for                          |
|------------|-------------------------------------|------------------------------------------------------|-----------------------------------|
| **YOLO**   | `yolo: true` in `.assemble.yaml`   | Production actions, missing info, external effects   | Daily development                 |
| **Hardcore**| `/yolo-hardcore` command            | Production only                                       | Trusted environments, fast iteration|
| **Full**   | `/yolo-full` command                | Nothing                                              | Maximum speed, accepts all risk   |

## Level 1 — YOLO (standard)

The default autonomous mode. Agents execute without intermediate validation but pause when:

- An action would affect **production** (deploy, database migration, etc.)
- **Required information is missing** and can’t be inferred
- An action has **external side effects** (sending emails, API calls, etc.)

### Configuration

```
yolo: true
```

### What changes

| Without YOLO                               | With YOLO                               |
|-------------------------------------------|----------------------------------------|
| Jarvis asks permission at each step       | Jarvis executes the full workflow      |
| Each deliverable requires validation      | Deliverables are produced continuously  |
| User controls the pace                    | Agents work at maximum speed           |
| More oversight                            | More speed                             |

## Level 2 — Hardcore

Escalation beyond standard YOLO. Agents work with near-full autonomy:

- Stop only for **production-impacting actions**
- **Infer** information that can reasonably be deduced from context
- Skip intermediate validations entirely

### Activation

```
/yolo-hardcore
```

This is a **runtime command** — not configurable in `.assemble.yaml`. Only a human can activate it, never an agent.

### What changes

- Agents interpret ambiguous requirements instead of asking
- Decisions are made autonomously based on best practices
- Only truly irreversible production actions trigger a pause

## Level 3 — Full

Maximum autonomy. Agents stop for **nothing**. Full trust, full speed, maximum risk.

### Activation

```
/yolo-full
```

This is also **runtime-only** and **human-activated only**.

### When to use it

- Prototyping where speed matters more than perfection
- Sandbox environments with no production risk
- When you want to see what the team produces without any guardrails

## Safety constraints

Regardless of YOLO level, these rules are **non-negotiable**:

1. **Hardcore and Full can only be activated by typing the command directly** — no agent can activate them for you
2. **Agents must still follow their anti-patterns** — YOLO doesn’t override quality rules
3. **The manifest is always updated** — you can review what happened after the fact
4. **Deliverables are always produced in `assemble-output/`** — nothing is lost

## Combining with governance

YOLO mode and governance are complementary:

| Governance | YOLO off                             | YOLO on                                 |
|------------|--------------------------------------|-----------------------------------------|
| none       | Manual validation at each step       | Full autonomous execution                |
| standard   | Decision gates at phase transitions   | Autonomous within phases, gates between |
| strict     | Full audit trail + gates             | Autonomous within phases, strict gates + audit |

With `governance: strict` + `yolo: true`, agents work autonomously within each phase but must still pass through formal decision gates between phases.

## Recommended configurations

### Solo developer / prototyping

```
yolo: true

governance: none
```

### Small team / startup

```
yolo: true

governance: standard
```

### Enterprise / regulated

```
yolo: false

governance: strict
```