DocsPlaybooks

Playbooks

Playbooks are repeatable, multi-step workflows that agents execute following a defined SOP. They combine the structure of a process document with the execution power of an AI team.

What playbooks are

A playbook is a Standard Operating Procedure (SOP) that agents can execute. Instead of a document that describes what should happen, a playbook is a living workflow that actually does the work. Define the steps, assign agents to each step, set checkpoints for human approval, and let the platform execute the process end to end.

Playbooks bring consistency to complex processes. Every quarterly business review follows the same structure. Every new employee onboarding hits the same checkpoints. Every client proposal goes through the same review stages. The agents handle execution; humans handle judgment.

Playbooks are parameterized. When you execute a playbook, you provide the inputs (client name, quarter, budget, etc.) and the agents fill in the details based on actual data from the knowledge base and connected systems.

Playbooks vs skills, workflows, and swarms

BOSS has several types of agent-executable patterns. Here is how they differ:

TypeDescriptionAgentsCheckpoints

SkillA single capability an agent can use: search, draft, analyze, calculate. Atomic operation.Single agentNone

WorkflowAn automated sequence triggered by an event. If X happens, do Y then Z. Event-driven.Single or fewOptional

SwarmMulti-agent collaboration on a single complex objective. Ad-hoc, project-based.MultipleBudget gates

PlaybookRepeatable, parameterized SOP with defined steps, agents, and human checkpoints. Process-based.MultipleRequired

Think of it this way: skills are verbs, workflows are if-then rules, swarms are project teams, and playbooks are repeatable process templates. A playbook can contain swarms as individual steps -- for example, a QBR playbook might have a "competitive analysis" step that runs a parallel swarm.

Example: Quarterly Business Review

Here is a complete playbook for preparing and delivering a Quarterly Business Review (QBR) for a client. This is one of the built-in templates available in the playbook library.

QBR Playbook6 steps, 4 agents, 2 checkpoints

Gather account dataNova

Pull revenue, usage, support tickets, and NPS data from connected systems (Salesforce, Stripe, Zendesk). Compile into a structured dataset.

Output: Data table + metrics summary

Analyze trends and insightsNova

Analyze quarter-over-quarter trends, identify anomalies, calculate growth rates, and flag at-risk metrics. Generate visualizations.

Output: Analysis document with charts

Draft QBR presentationForge

Create a presentation deck with executive summary, key metrics, trend analysis, wins, challenges, and recommendations for next quarter.

Output: QBR presentation document

Internal reviewReedCheckpoint

Review the deck for messaging consistency, tone, and completeness. Flag any claims that need data backing or sections that need human judgment.

Output: Review notes

Account owner reviews and approves before client delivery

Generate talking pointsAtlas

Create a briefing document with talking points for each slide, anticipated client questions, and suggested responses. Include expansion opportunities.

Output: Talking points document

Send to clientReedCheckpoint

Draft the client email with the QBR deck attached, scheduling link for the review call, and summary of key highlights.

Output: Client email

Account owner approves email before sending to client

Executing a playbook

Playbooks can be executed from the studio UI (click "Run Playbook"), from the API, or triggered by ambient agents on a schedule (e.g., run the QBR playbook automatically 2 weeks before each quarter end).

When a playbook hits a checkpoint, execution pauses and the designated approver is notified via their preferred channel (Slack, Teams, email, or in-app). The approver can review the outputs, provide feedback, and approve or reject. If rejected, the playbook loops back to the failed step with the feedback.

execute-playbook.ts

// Execute a playbook const execution = await boss.playbooks.execute({ playbookId: 'pb_qbr_standard', studioId: 'stu_sales_01', parameters: { quarter: 'Q2 2026', clientName: 'Acme Corp', accountOwnerId: 'usr_jsmith', revenueTarget: 450000, }, notifications: { checkpoints: 'slack', // Notify on Slack when human approval needed completion: 'email', // Email when playbook finishes }, }); // Check execution status const status = await boss.playbooks.getStatus(execution.id); // { // phase: 'step_3_draft_review', // progress: 0.42, // checkpoint: { // waiting: true, // step: 'executive_review', // message: 'QBR deck draft ready for review before client delivery', // artifacts: ['doc_qbr_deck_draft', 'table_metrics_summary'], // } // } // Approve a checkpoint to continue await boss.playbooks.approveCheckpoint(execution.id, { approved: true, feedback: 'Looks good. Add a slide on the expansion opportunity.', });

Checkpoint actions:

Approve: Continue execution from the current step. Optionally add feedback for the next agent.

Approve with changes: Continue, but include feedback that the previous step's agent should address in a revision.

Reject: Send the playbook back to the failed step with rejection feedback. The agent revises and re-submits.

Delegate: Forward the checkpoint to another approver (e.g., escalate to a senior stakeholder).

Creating custom playbooks

You can create custom playbooks from scratch, clone and modify a template, or have an agent generate one from a natural language description of your process. Custom playbooks support:

Parameterized inputs (strings, dates, numbers, enums, user references)

Sequential and parallel step execution

Step dependencies (step B waits for step A to complete)

Conditional steps (run step C only if step A produced a certain result)

Human checkpoints with configurable approvers

Scheduled steps (run step X on a specific date or N days before a deadline)

Swarm steps (a single step can invoke a full multi-agent swarm)

Webhook notifications at any step

Retry logic for failed steps with configurable max retries

custom-playbook.ts

// Create a custom playbook const playbook = await boss.playbooks.create({ name: 'New Employee Onboarding', description: 'Standard 30-day onboarding workflow for new hires', studioId: 'stu_hr_01', parameters: [ { name: 'employeeName', type: 'string', required: true }, { name: 'department', type: 'enum', values: ['Engineering', 'Sales', 'Marketing', 'Operations'], required: true }, { name: 'startDate', type: 'date', required: true }, { name: 'managerId', type: 'user', required: true }, ], steps: [ { id: 'prep_accounts', name: 'Prepare accounts and access', agent: 'loom', action: 'Create checklist of required accounts, tools, and permissions based on department', output: 'checklist', autoApprove: true, }, { id: 'welcome_kit', name: 'Generate welcome materials', agent: 'forge', action: 'Create personalized welcome doc, org chart, and first-week schedule', output: 'document', dependsOn: ['prep_accounts'], autoApprove: true, }, { id: 'training_plan', name: 'Build training plan', agent: 'atlas', action: 'Create 30-day training plan with milestones based on role and department', output: 'document', dependsOn: ['prep_accounts'], autoApprove: false, // Manager must approve checkpoint: { approver: '{{managerId}}', message: 'Please review the 30-day training plan before sharing with the new hire', }, }, { id: 'notify_team', name: 'Send team notification', agent: 'reed', action: 'Draft and send team introduction email and Slack announcement', output: 'communication', dependsOn: ['welcome_kit', 'training_plan'], autoApprove: false, checkpoint: { approver: '{{managerId}}', message: 'Review the team introduction before sending', }, }, { id: 'day_one_checklist', name: 'Day-one setup checklist', agent: 'loom', action: 'Create day-one checklist with equipment, badge, parking, and orientation schedule', output: 'checklist', dependsOn: ['prep_accounts'], autoApprove: true, scheduledFor: '{{startDate}} - 2d', // 2 days before start date }, ], });

Built-in playbook templates: BOSS includes 20+ playbook templates out of the box: Quarterly Business Review, New Employee Onboarding, Client Proposal, Sprint Retrospective, Incident Response, Content Publication, Compliance Audit Prep, Board Meeting Prep, Customer Offboarding, and more. Browse them at /admin/playbooks/templates.

Knowledge Base

Swarm Engine