Working style

Note: Working Style replaces the previous "Check-ins" feature. Instead of periodic check-ins during task execution, you now choose between Collaborative mode (asks questions and explains approach), Supervised mode (plans collaboratively, then executes autonomously), or Autonomous mode (uses best judgment and keeps going).

Overview

Working Style controls how Friday approaches tasks and communicates with you. There are three modes: Collaborative, Supervised, and Autonomous. In Collaborative mode (default), Friday asks clarifying questions and explains its approach before making changes. In Supervised mode, Friday plans collaboratively with you, then executes the plan autonomously without further interruptions. In Autonomous mode, Friday uses its best judgment and keeps going until the task is complete.

Quick Start

Configure your working style through the settings menu:

/settings

Select "Working Style" and choose between Collaborative, Supervised, or Autonomous mode.

Usage

Working Style Modes

Collaborative Mode (Default)

In Collaborative mode, Friday takes a thoughtful, interactive approach:

  • Asks clarifying questions before making assumptions
  • Explains the planned approach before implementing changes
  • Gives you opportunities to provide guidance and direction
  • Ensures alignment with your expectations throughout the task

This mode is ideal when you want to stay involved in the decision-making process and maintain close oversight of Friday's work.

Supervised Mode

In Supervised mode, Friday combines collaborative planning with autonomous execution:

  • Asks clarifying questions and explains the planned approach upfront
  • Waits for your confirmation before starting work
  • Executes the approved plan autonomously without further interruptions
  • Provides a summary of what was implemented when done

This mode is ideal when you want to review and approve the plan before work begins, but don't want to be interrupted during execution.

Autonomous Mode

In Autonomous mode, Friday works more independently:

  • Uses best judgment when details are unclear
  • Keeps going until the task is complete
  • Makes reasonable assumptions to maintain momentum
  • Minimizes interruptions for clarification

This mode is ideal when you want Friday to work with minimal interruption and trust it to make reasonable decisions.

When to Use Collaborative Mode

Use Collaborative mode when:

  • Working on complex, multi-step tasks
  • You're unsure about the exact approach
  • The task requires specific implementation details
  • You want to review the plan before work begins
  • You prefer to guide Friday through the process

When to Use Supervised Mode

Use Supervised mode when:

  • You want to review and approve the approach before execution begins
  • The task is complex enough to warrant planning, but well-defined enough to execute without check-ins
  • You want the efficiency of autonomous execution without giving up visibility into the plan
  • You trust Friday to follow through on an agreed plan without hand-holding

When to Use Autonomous Mode

Use Autonomous mode when:

  • Working on straightforward tasks with clear requirements
  • You're confident Friday understands the context
  • You want Friday to work without interruption
  • The task is well-defined and unlikely to need clarification
  • You trust Friday to make reasonable decisions

Examples

Complex Refactoring with Collaborative Mode

Refactor the authentication system to use a new token-based approach

In Collaborative mode, Friday will:

  1. Ask clarifying questions: "Should I maintain backward compatibility with the existing auth system? What token format would you prefer (JWT, opaque tokens)?"
  2. Explain the planned approach: "I'll create a new TokenAuthService, update the middleware to support both old and new auth methods during migration, and add tests for the token validation logic."
  3. Wait for your confirmation before proceeding
  4. Keep you informed throughout the implementation

API Integration with Supervised Mode

Integrate the Stripe payment API and add webhook handling

In Supervised mode, Friday will:

  1. Ask clarifying questions: "Which Stripe events should the webhook handle? Should I use the existing error handling patterns in the codebase?"
  2. Explain the full plan: "I'll install the Stripe SDK, create a PaymentService, add webhook endpoint with signature verification, and write tests for the key flows."
  3. Wait for your approval before starting
  4. Execute the entire plan autonomously without interrupting you
  5. Provide a summary of everything implemented when done

Large Feature Implementation with Autonomous Mode

Add a new dashboard feature with charts and data visualization

In Autonomous mode, Friday will:

  • Analyze the existing codebase to understand the project structure
  • Make reasonable decisions about component architecture and library choices
  • Implement the feature with sensible defaults
  • Complete the task without interrupting you for clarification
  • Provide a summary of what was implemented when done

Debugging with Collaborative Mode

The payment processing is failing intermittently, investigate and fix

In Collaborative mode, Friday will:

  • Ask about the symptoms: "When does the failure occur? Are there any error messages in the logs?"
  • Explain the investigation approach before starting
  • Share findings and proposed solutions for your review
  • Wait for approval before implementing the fix

Quick Fix with Autonomous Mode

Fix the typo in the README file

In Autonomous mode, Friday will:

  • Locate and fix the typo immediately
  • Complete the task without interruption
  • Provide a brief summary of what was changed

Switching Between Modes

You can change your working style at any time through settings:

/settings

Select "Working Style" and toggle between Collaborative, Supervised, and Autonomous mode.

What happens to running threads when you switch

Working Style ends up in two different places. It shapes each thread's system prompt (the agent is told to "ask questions" or "keep going"), and it controls a few runtime gates like the accept-thread confirmation modal.

When you change Working Style mid-session:

  • The thread you ran /settings from gets its system prompt refreshed. Its behavior changes on the next turn.
  • Other already-running threads keep the prompt they were spawned with. They'll keep behaving under the old Working Style until they finish.
  • New threads spawned after the change pick up the new value.
  • Runtime gates read the setting live. Flipping from Collaborative to Autonomous mid-session skips upcoming "Ready to accept" prompts even on threads that are already running.

If you want existing threads to fully behave under the new Working Style (not just skip the accept prompt), abandon them and re-dispatch.