### Agent OS: Use Different Profile

Source: https://buildermethods.com/agent-os/installation

This example demonstrates how to specify a different profile for the project installation using the --profile flag. This allows users to switch between pre-defined project configurations.

```bash
~/agent-os/scripts/project-install.sh --profile nextjs
```

--------------------------------

### Agent OS: Preview Installation (Dry Run)

Source: https://buildermethods.com/agent-os/installation

This command performs a dry run of the project installation process. It simulates the installation without making any actual changes to the system, allowing users to preview the intended actions.

```bash
~/agent-os/scripts/project-install.sh --dry-run
```

--------------------------------

### Agent OS: Enable Claude Code Skills

Source: https://buildermethods.com/agent-os/installation

This example demonstrates enabling Claude Code commands and configuring standards to be used as Claude Code skills. This enhances the AI's ability to adhere to coding standards within its operations.

```bash
~/agent-os/scripts/project-install.sh --claude-code-commands true --standards-as-claude-code-skills true
```

--------------------------------

### Install Agent OS Base System (Shell)

Source: https://buildermethods.com/agent-os/installation

This command installs the base Agent OS system to your home directory. It downloads and executes a script that sets up the default profile with necessary components. For Windows users, WSL or Git Bash is recommended.

```shell
curl -sSL https://raw.githubusercontent.com/buildermethods/agent-os/main/scripts/base-install.sh | bash
```

--------------------------------

### Navigate to Project Directory (Shell)

Source: https://buildermethods.com/agent-os/installation

This command changes the current directory to your project's root folder, preparing it for the Agent OS project installation. Replace '/path/to/your/project' with the actual path to your project.

```shell
cd /path/to/your/project
```

--------------------------------

### Install Agent OS into Project (Shell)

Source: https://buildermethods.com/agent-os/installation

This script installs Agent OS into your current project directory. It uses default configurations from `~/agent-os/config.yml` or prompts for user input regarding profile selection and other options.

```shell
~/agent-os/scripts/project-install.sh
```

--------------------------------

### Agent OS: Enable Claude Code without Subagents

Source: https://buildermethods.com/agent-os/installation

This example shows how to enable Claude Code commands while explicitly disabling subagents. This is useful for users who want Claude Code features without the overhead or specific behavior of subagents.

```bash
~/agent-os/scripts/project-install.sh --claude-code-commands true --use-claude-code-subagents false
```

--------------------------------

### Agent OS: Enable Other AI Coding Tools

Source: https://buildermethods.com/agent-os/installation

This command enables general Agent OS commands, which can be used to integrate with or support other AI coding tools beyond Claude Code. It uses the --agent-os-commands flag.

```bash
~/agent-os/scripts/project-install.sh --agent-os-commands true
```

--------------------------------

### Install Agent OS 2.0 Base Script

Source: https://buildermethods.com/agent-os/version-2

This command downloads and executes the base installation script for Agent OS version 2.0. It's the first step in setting up the new version, typically creating the agent-os directory in the user's home folder.

```bash
curl -sSL https://github.com/buildermethods/agent-os/raw/main/scripts/base-install.sh | bash
```

--------------------------------

### Agent OS: Enable Claude Code with Subagents

Source: https://buildermethods.com/agent-os/installation

This command enables Claude Code functionality and activates subagents for enhanced AI coding capabilities. It requires setting both --claude-code-commands and --use-claude-code-subagents flags to true.

```bash
~/agent-os/scripts/project-install.sh --claude-code-commands true --use-claude-code-subagents true
```

--------------------------------

### Workflow Injection Syntax Example

Source: https://buildermethods.com/agent-os/workflows

This demonstrates the syntax used to embed workflow content into command, agent, or other workflow files. Agent OS replaces this placeholder with the actual content of the specified workflow file during project installation.

```text
{{workflows/specification/write-spec}}
```

--------------------------------

### Installing Agent OS with a Specific Profile

Source: https://buildermethods.com/agent-os/profiles

Demonstrates how to install Agent OS into a project using a profile different from the default. The `--profile` flag is used with the `project-install.sh` script, specifying the desired profile name (e.g., 'django-api').

```bash
~/agent-os/scripts/project-install.sh --profile django-api
```

--------------------------------

### Migrate Product and Specs Folders

Source: https://buildermethods.com/agent-os/version-2

These commands move the `product` and `specs` folders from your old `.agent-os` installation to the new `agent-os` directory. This preserves your existing product documentation and specifications for use with Agent OS 2.0.

```bash
cd /path/to/your/project
mv .agent-os/product agent-os/product
mv .agent-os/specs agent-os/specs
```

--------------------------------

### Standards Injection Syntax Example

Source: https://buildermethods.com/agent-os/workflows

This shows the syntax for injecting standards into Agent OS files. It supports specific file references and wildcard usage for including all files within a directory. Unlike workflows, standards are injected as @ references.

```text
{{standards/global/*}}
{{standards/backend/database}}
```

--------------------------------

### Conditional Compilation Tags Example (Agent OS)

Source: https://buildermethods.com/agent-os/workflows

This example illustrates the use of conditional compilation tags in Agent OS workflows. `{{IF}}` and `{{UNLESS}}` tags allow content to be dynamically included or excluded based on project configuration options, enabling adaptive workflows.

```text
{{IF use_claude_code_subagents}}
## Delegating to subagents

For each task group in orchestration.yml:
1. Identify which specialized subagent should handle it
2. Create a new agent session for that subagent
3. Provide the task group and relevant context

{{ENDIF use_claude_code_subagents}}
{{UNLESS standards_as_claude_code_skills}}

```

--------------------------------

### Dual Setup: Claude Code + Other Tools Configuration

Source: https://buildermethods.com/agent-os/modes

This configuration enables both Claude Code commands and general Agent OS commands, offering maximum flexibility. It allows users to switch between Claude Code's features and prompt-based commands for other AI coding tools.

```yaml
claude_code_commands: true
use_claude_code_subagents: true
standards_as_claude_code_skills: true
agent_os_commands: true
```

--------------------------------

### Update Agent OS Project Installation Script (Shell)

Source: https://buildermethods.com/agent-os/updating

This script updates an individual project installation of Agent OS. It compares the current configuration with the incoming version, shows changes, and prompts for confirmation before proceeding. It preserves important project data like specs and product docs while reinstalling other components from the base installation.

```shell
~/agent-os/scripts/project-update.sh
```

--------------------------------

### Traditional Standards Injection Example

Source: https://buildermethods.com/agent-os/skills

This example demonstrates the traditional method of injecting coding standards in Agent OS by explicitly referencing standard files within commands or agent instructions. This method ensures standards are always read but can consume significant context tokens.

```text
@agent-os/standards/global/naming.md
@agent-os/standards/backend/api-design.md
@agent-os/standards/frontend/component-patterns.md
```

--------------------------------

### Injecting a New Workflow (Markdown)

Source: https://buildermethods.com/agent-os/workflows

This example shows how to inject a newly created workflow into Agent OS. The workflow, defined in a markdown file (e.g., 'workflows/deployment/deploy-staging.md'), can be referenced using the `{{workflows/[path]/[name]}}` syntax within commands, agents, or other workflows.

```markdown
## Final Steps
{{workflows/deployment/deploy-staging}}
```

--------------------------------

### Run /implement-tasks with Claude Code

Source: https://buildermethods.com/agent-os/implement-tasks

This command is used to initiate the task implementation process when using Agent OS with Claude Code commands enabled. It's a direct way to start the implementation phase for your tasks.

```bash
/implement-tasks
```

--------------------------------

### Example orchestration.yml Configuration

Source: https://buildermethods.com/agent-os/orchestrate-tasks

This YAML file demonstrates the structure of `orchestration.yml` generated by the `orchestrate-tasks` command. It specifies task groups, assigns Claude Code subagents, and defines the standards to be applied to each group.

```yaml
task_groups:
  - name: authentication-system
    claude_code_subagent: backend-specialist
    standards:
      - all
  - name: user-dashboard
    claude_code_subagent: frontend-specialist
    standards:
      - global/*
      - frontend/components.md
      - frontend/css.md
  - name: api-endpoints
    claude_code_subagent: backend-specialist
    standards:
      - backend/*
      - global/error-handling.md
```

--------------------------------

### Update Agent OS Base Installation Script (Shell)

Source: https://buildermethods.com/agent-os/updating

This script updates the base installation of Agent OS located in `~/agent-os`. It detects the current version, prompts for confirmation, backs up the existing installation, and then applies the update. It ensures you have the latest core scripts, default profile, workflows, and agents.

```shell
curl -sSL "https://raw.githubusercontent.com/buildermethods/agent-os/main/scripts/base-install.sh" | bash
```

--------------------------------

### Setting the Default Agent OS Profile

Source: https://buildermethods.com/agent-os/profiles

Illustrates how to set the default profile for all Agent OS project installations. This is done by modifying the `config.yml` file in the base installation and specifying the desired profile name (e.g., 'general').

```yaml
default_profile: general
```

--------------------------------

### Update Agent OS in Project

Source: https://buildermethods.com/agent-os/updating

Applies updates from your base Agent OS installation to a specific project. This script will show proposed changes and prompt for confirmation before proceeding. It assumes the Agent OS scripts are located in `~/agent-os/scripts/`.

```shell
cd /path/to/your/project
~/agent-os/scripts/project-update.sh
```

--------------------------------

### Provide Playwright Tools to Custom Claude Code Agents

Source: https://buildermethods.com/agent-os/visuals

This example demonstrates how to grant custom Claude Code subagents access to Playwright tools for browser-based visual verification. Including Playwright enhances the reliability and accuracy of UI implementation by enabling agents to perform automated screenshot comparisons.

```python
from claude_code.tools import playwright

# Assume 'custom_subagent' is an instance of a Claude Code subagent
custom_subagent.add_tool(playwright.screenshot)
custom_subagent.add_tool(playwright.compare_screenshots)
```

--------------------------------

### Specify Visuals Directory in Agent OS

Source: https://buildermethods.com/agent-os/visuals

This snippet shows the directory structure where visual assets should be placed during the research phase of Agent OS development. Agent OS automatically detects and analyzes image files in this location to guide agent behavior.

```shell
agent-os/specs/[this-spec]/planning/visuals/
```

--------------------------------

### Default Standards Folder Structure in Agent OS

Source: https://buildermethods.com/agent-os/standards

This snippet shows the default directory structure for storing standards within an Agent OS base installation. These folders help organize standards for different parts of a project, such as backend, frontend, global settings, and testing.

```text
~/agent-os/profiles/default/standards/
├── backend/
├── frontend/
├── global/
└── testing/
```

--------------------------------

### Run plan-product command with Other AI Tools (Manual Steps)

Source: https://buildermethods.com/agent-os/plan-product

This option provides more granular control by allowing users to execute each step of the `plan-product` command individually when using AI coding tools. This approach enhances reliability and allows for intervention between steps.

```bash
@agent-os/commands/plan-product/1-plan-product.md run this
```

```bash
@agent-os/commands/plan-product/2-create-mission.md run this
```

```bash
@agent-os/commands/plan-product/3-create-roadmap.md run this
```

```bash
@agent-os/commands/plan-product/4-create-tech-stack.md run this
```

--------------------------------

### Run plan-product command with Other AI Tools (All Steps)

Source: https://buildermethods.com/agent-os/plan-product

This command allows users to run all steps of the `plan-product` process sequentially with a single instruction when using AI coding tools other than Claude Code. This method is suitable for agents that perform well with multi-step automation.

```bash
@agent-os/commands/plan-product/plan-product.md run this
```

--------------------------------

### Run /plan-product with Claude Code

Source: https://buildermethods.com/agent-os/plan-product

This command initiates the product planning process using Agent OS with Claude Code enabled. The `product-planner` subagent interactively gathers information to create essential product documents in the `agent-os/product/` directory.

```bash
/plan-product
```

--------------------------------

### Remove Agent OS 1.x Project Installation

Source: https://buildermethods.com/agent-os/version-2

This command removes the old 1.x project-specific installation folder for Agent OS after a project has been updated to 2.0. It's important to confirm the project is fully migrated before deletion.

```shell
rm -rf /path/to/your/project/.agent-os
```

--------------------------------

### Remove Agent OS 1.x Base Installation

Source: https://buildermethods.com/agent-os/version-2

This command removes the old 1.x base installation folder for Agent OS. Ensure you have successfully migrated and merged your configurations before executing this command to avoid data loss.

```shell
rm -rf ~/.agent-os
```

--------------------------------

### Running Agent OS Commands with Other AI Tools

Source: https://buildermethods.com/agent-os/adaptability

This section demonstrates how to execute Agent OS workflow commands when using AI tools other than Claude Code. It provides two options: running the main command file for automatic completion of all steps or running individual numbered command files sequentially for greater control.

```markdown
@agent-os/commands/write-spec/write-spec.md run this
```

```markdown
@agent-os/commands/write-spec/1-[step-name].md run this
@agent-os/commands/write-spec/2-[step-name].md run this
```

--------------------------------

### Run `create-tasks` with Other AI Tools (Manual Steps)

Source: https://buildermethods.com/agent-os/create-tasks

For greater control, you can execute individual numbered commands sequentially from the `agent-os/commands/create-tasks/` directory to perform the task creation process step-by-step.

```bash
cd agent-os/commands/create-tasks/
# Execute numbered command files sequentially
```

--------------------------------

### Assigning Standards in Agent OS

Source: https://buildermethods.com/agent-os/workflows

This snippet demonstrates how to reference standards using path-like strings within Agent OS. Standards can be specified as 'all' for every folder, 'global/*' for all standards in the global folder, or a specific file path like 'frontend/components.md'. This allows for flexible and granular control over implementation guidelines.

```text
all
global/*
frontend/components.md
```

--------------------------------

### Run implement-tasks Command - All Steps (Other Tools)

Source: https://buildermethods.com/agent-os/implement-tasks

This command automates the entire task implementation process in a single execution when using AI coding tools other than Claude Code. It's a convenient option for users who prefer a fully automated approach, though agent performance may vary.

```bash
@agent-os/commands/implement-tasks/implement-tasks.md run this
```

--------------------------------

### Creating a New Workflow (Markdown)

Source: https://buildermethods.com/agent-os/workflows

This snippet illustrates how to create a new workflow in Agent OS. A new markdown file is added to the custom profile's 'workflows/' directory. This file contains self-contained instructions that can be injected into commands or agents using a specific syntax.

```markdown
# Deploy to Staging

After implementation is verified:

1. Run the staging deployment script:
   ```bash
   npm run deploy:staging
   ```

2. Verify the deployment at https://staging.example.com

3. Run smoke tests to ensure core functionality works
```

--------------------------------

### Creating a Custom Agent OS Profile

Source: https://buildermethods.com/agent-os/profiles

Shows the command to create a new custom profile in Agent OS. The `create-profile.sh` script generates the necessary directory structure, configuration file, and sets up inheritance. It facilitates customization by allowing edits to files copied from other profiles.

```bash
~/agent-os/scripts/create-profile.sh
```

--------------------------------

### Run `create-tasks` with Claude Code

Source: https://buildermethods.com/agent-os/create-tasks

This command is used when Agent OS is integrated with Claude Code. It initiates the task creation process directly within the Claude Code environment.

```bash
/create-tasks
```

--------------------------------

### Overriding Workflows with Profile Inheritance (Bash)

Source: https://buildermethods.com/agent-os/workflows

This example shows how to override default workflows in Agent OS by using profile inheritance. A custom profile inherits from 'default', and a workflow file is copied and modified within the custom profile's directory. The custom version is then used when the workflow is injected.

```bash
cp ~/agent-os/profiles/default/workflows/specification/write-spec.md ~/agent-os/profiles/my-profile/workflows/specification/write-spec.md
```

--------------------------------

### Run `create-tasks` with Other AI Tools (All Steps)

Source: https://buildermethods.com/agent-os/create-tasks

This option allows you to run the entire `create-tasks` process in a single command when using AI coding tools other than Claude Code. It automates the breakdown of the spec into tasks.

```bash
@agent-os/commands/create-tasks/create-tasks.md run this
```

--------------------------------

### Claude Code with Skills Integration Configuration

Source: https://buildermethods.com/agent-os/modes

This YAML configuration enables Claude Code commands and leverages Claude Code Skills for intelligent standards application. It's the recommended default, providing context-efficient standards adherence.

```yaml
claude_code_commands: true
use_claude_code_subagents: true
agent_os_commands: false
standards_as_claude_code_skills: true
```

--------------------------------

### Default Agent OS Profile Structure

Source: https://buildermethods.com/agent-os/profiles

Illustrates the directory structure of the default Agent OS profile. This profile serves as the foundation for standards and patterns used across most projects. It's recommended to keep the default profile unchanged and create custom profiles that inherit from it.

```tree
~/agent-os/profiles/default/
├── standards/
│   ├── global/...
│   ├── backend/...
│   ├── frontend/...
│   └── testing/...
├── workflows/...
├── agents/...
└── commands/...
```

--------------------------------

### Run shape-spec Command with Claude Code

Source: https://buildermethods.com/agent-os/shape-spec

This command is used when Agent OS is integrated with Claude Code. Running `/shape-spec` initiates the feature planning process by examining the product roadmap (`agent-os/product/roadmap.md`) or accepting a raw feature description.

```shell
/shape-spec
```

--------------------------------

### Run write-spec Command with Claude Code

Source: https://buildermethods.com/agent-os/write-spec

This code snippet shows how to execute the `write-spec` command when using Agent OS with Claude Code commands enabled. It's a straightforward command invocation.

```shell
/write-spec
```

--------------------------------

### Configuration for Other AI Coding Tools

Source: https://buildermethods.com/agent-os/modes

This configuration is designed for AI coding tools other than Claude Code, such as Cursor, Codex, or Gemini. It enables the generation of Agent OS workflow commands that can be used as sequential prompts.

```yaml
claude_code_commands: false
use_claude_code_subagents: false
standards_as_claude_code_skills: true
agent_os_commands: true
```

--------------------------------

### Create New Spec Folder Structure

Source: https://buildermethods.com/agent-os/shape-spec

This code block illustrates the directory structure created by the `shape-spec` command. It initializes a new spec folder within the project's `specs` directory, containing a `planning` subfolder with `visuals` and `requirements.md`.

```bash
agent-os/specs/2025-10-15-user-auth/
└── planning/
    ├── visuals/
    └── requirements.md
```

--------------------------------

### Custom Profile Organization Pattern in Agent OS

Source: https://buildermethods.com/agent-os/standards

Illustrates a common pattern for organizing custom profiles in Agent OS, utilizing inheritance. This structure allows for a base 'default' profile, a 'general' custom profile, and specialized profiles for different tech stacks like 'rails' and 'react', promoting modularity and maintainability.

```text
~/agent-os/profiles/
├── default/          # Base profile (don't customize)
├── general/          # Your main custom profile
│   └── standards/    # General tweaks to defaults
├── rails/            # Tech-stack-specific profile
│   └── standards/    # Rails-specific standards
└── react/            # Tech-stack-specific profile
    └── standards/    # React-specific standards
```

--------------------------------

### Run write-spec Command with Other Tools (All Steps)

Source: https://buildermethods.com/agent-os/write-spec

This command instructs an agent to complete the entire `write-spec` process automatically when using AI coding tools other than Claude Code. Some agents may perform better with this all-in-one approach.

```shell
@agent-os/commands/write-spec/write-spec.md run this
```

--------------------------------

### Run Orchestrate Tasks Command (Other Tools - All Steps)

Source: https://buildermethods.com/agent-os/orchestrate-tasks

This command is used with other AI coding tools to run the entire `orchestrate-tasks` process in a single execution. It instructs the agent to complete the orchestration process automatically, which may yield varying results depending on the agent's capabilities.

```shell
@agent-os/commands/orchestrate-tasks/orchestrate-tasks.md run this
```

--------------------------------

### Claude Code with Subagent Delegation Configuration

Source: https://buildermethods.com/agent-os/modes

This configuration is optimized for using Claude Code with its subagent delegation feature enabled. It prioritizes autonomous task handling by specialized subagents for a more hands-off development experience.

```yaml
claude_code_commands: true
use_claude_code_subagents: true
standards_as_claude_code_skills: true
agent_os_commands: false
```

--------------------------------

### Default Agent OS Configuration

Source: https://buildermethods.com/agent-os/modes

This YAML snippet shows the default configuration settings for Agent OS, typically found in the `~/agent-os/config.yml` file. It enables Claude Code commands and subagent delegation by default, while disabling general Agent OS commands.

```yaml
defaults:
  profile: default
  claude_code_commands: true
  use_claude_code_subagents: true
  agent_os_commands: false
  standards_as_claude_code_skills: true
```

--------------------------------

### Finding Workflow Injection Points (Bash)

Source: https://buildermethods.com/agent-os/workflows

This bash command demonstrates how to find all occurrences where a specific workflow is injected within Agent OS profiles. The `grep -r` command searches recursively through the 'default' profile directory for the injection syntax, helping to understand the impact of workflow changes.

```bash
grep -r "{{workflows/implementation/verify" ~/agent-os/profiles/default/
```

--------------------------------

### Workflow Directory Structure

Source: https://buildermethods.com/agent-os/workflows

This shows the default organization of workflow files within the Agent OS profiles directory. Workflows are categorized by development phase (planning, specification, implementation, verification) and follow the profile's inheritance system.

```shell
#  Workflows: Modular Building Blocks 

Workflows are modular instruction blocks that Agent OS uses to assemble consistent instructions across configuration options and commands. They're the building blocks that power the spec-driven development workflow.

**Most users never need to customize workflows.** Agent OS includes a comprehensive set of pre-built workflows that handle the entire development process. But if you want fine-grain control over how instructions are assembled and how standards get injected into your agents, understanding workflows helps.

This page covers:
  * What workflows are
  * How workflows are organized
  * How the injection system works
  * Conditional compilation tags
  * When to customize workflows


## What workflows are
Workflows are reusable markdown files containing instructions for specific parts of the development process. They get injected into:
  * **Command files** - Instructions for Agent OS commands that guide your development workflow
  * **Custom Claude Code subagents** - When creating specialized subagents for complex orchestration


This modular approach ensures consistency: the same process instructions appear everywhere they're needed, regardless of your configuration options.
## How workflows are organized
Workflows live inside your profiles and follow the same inheritance system as standards.

The default profile organizes workflows by development phase:
```
~/agent-os/profiles/default/workflows/
├── planning/
│   ├── research-feature.md
│   └── plan-roadmap.md
├── specification/
│   ├── write-spec.md
│   └── analyze-requirements.md
└── implementation/
    ├── implement-tasks.md
    └── verification/
        └── verify-implementation.md
```

When you install Agent OS into a project, these workflows are compiled into your project's commands and agents based on your active profile.
## How the injection system works
Agent OS uses a simple injection syntax to embed workflows (and standards) wherever instructions are needed.
### Workflow injection syntax
Workflows are injected using this syntax in any command, agent, or workflow file:
```
{{workflows/specification/write-spec}}
```

During project installation, Agent OS finds this placeholder and replaces it with the contents of `write-spec.md`.
### Standards injection syntax
Similarly, standards get injected using this syntax:
```
{{standards/global/*}}
{{standards/backend/database}}
```

The `*` wildcard includes all files in that folder. Without it, you're referencing a specific file (without the `.md` extension).
**Note:** An important difference between injecting standards vs. workflows: standards are injected as a list of @ references to the files in your project's `agent-os/standards` folder, while workflows are injected as the file contents themselves.
### How compilation happens
When you run project installation, Agent OS:
  1. Scans all command and agent files for injection placeholders
  2. Locates the referenced workflow or standard files in your active profile
  3. Replaces each placeholder with the file contents
  4. Validates that all referenced files exist


The result is fully compiled commands and agents with all instructions assembled and ready to use.
## Conditional compilation tags
Workflows can include conditional tags that show or hide content based on your project's configuration options. This allows workflows to adapt automatically to different setups without requiring multiple versions.
### Available conditional tags
Use these tags to conditionally include or exclude content during compilation:
  * **`{{IF condition}}`...`{{ENDIF condition}}`** - Include content when condition is true
  * **`{{UNLESS condition}}`...`{{ENDUNLESS condition}}`** - Include content when condition is false


### Common configuration conditions
The most frequently used conditions in workflows are:
  * `use_claude_code_subagents` - True when using Claude Code subagents for task orchestration
  * `standards_as_claude_code_skills` - True when using Claude Code Skills integration for standards application


### Example: Adaptive workflow instructions
Here's how the orchestrate-tasks workflow adapts to different configurations:
```
{{IF use_claude_code_subagents}}
## Delegating to subagents

For each task group in orchestration.yml:
1. Identify which specialized subagent should handle it
2. Create a new agent session for that subagent
3. Provide the task group and relevant context

{{ENDIF use_claude_code_subagents}}
{{UNLESS standards_as_claude_code_skills}}

```

--------------------------------

### Run Orchestrate Tasks Command (Claude Code)

Source: https://buildermethods.com/agent-os/orchestrate-tasks

This command initiates the `orchestrate-tasks` process when using Agent OS with Claude Code commands enabled. It will automatically create the `orchestration.yml` file, prompt for subagent and standards assignments, and then delegate tasks or generate prompts.

```shell
/orchestrate-tasks
```

--------------------------------

### Configure Agent OS for Claude Code Skills

Source: https://buildermethods.com/agent-os/skills

This configuration snippet shows how to enable Claude Code commands and the 'standards_as_claude_code_skills' option in Agent OS. Enabling these settings allows Agent OS to convert coding standards into Claude Code Skills for intelligent application. This is typically found in `~/agent-os/config.yml`.

```yaml
defaults:
  profile: default
  claude_code_commands: true
  use_claude_code_subagents: true
  agent_os_commands: false
  standards_as_claude_code_skills: true  # Skills enabled
```

--------------------------------

### Switch Agent OS Project Profile

Source: https://buildermethods.com/agent-os/updating

Re-installs Agent OS within your project using a specified new profile. This command effectively resets the Agent OS configuration to match the new profile's settings. Ensure the profile name is correct.

```shell
~/agent-os/scripts/project-install.sh --profile your-new-profile
```

--------------------------------

### Profile Inheritance Configuration

Source: https://buildermethods.com/agent-os/profiles

Demonstrates how to configure profile inheritance in Agent OS. A profile can inherit from a parent profile (e.g., 'default') and override specific files or add new elements. The 'inherits_from' key specifies the parent profile, and 'exclude_inherited_files' allows selective exclusion of inherited files.

```yaml
inherits_from: default
```

```yaml
inherits_from: default

exclude_inherited_files:
  - standards/backend/api.md
```